@mmerterden/multi-agent-pipeline 19.1.3 → 19.1.4

package/pipeline/scripts/memory-load.sh

@@ -11,9 +11,9 @@
 # scripts/_retrieval.mjs) and the most relevant are printed. Without it the
 # index order is kept, which is what every existing caller gets.
 #
-# The cap used to be a bare `head -30`. That is a truncation, not a summary: the
-# thirty-first pointer was invisible however precisely it matched the task, and
-# the block got less useful the longer a repo was worked on - the opposite of
+# The cap is not a bare `head -30`. That is a truncation, not a summary: the
+# thirty-first pointer stays invisible however precisely it matches the task, and
+# the block gets less useful the longer a repo is worked on - the opposite of
 # what accumulated memory is for.
 #
 # Honors `prefs.global.perRepoMemory`. When the pref is off OR the prefs file

package/pipeline/scripts/plan-coverage-gate.mjs

@@ -77,9 +77,9 @@ export function filesToAdd(markdown) {
     if (!path || /^-+$/.test(path)) continue;
     if (path.includes("<") || tag.includes("<")) continue;
     // No header-row filter: the tag column of the header reads "Etiket / Tag",
-    // which the `Add new` test below already rejects. The filter that used to be
-    // here matched on the PATH column instead and would have skipped a real row
-    // whose path begins with a `File/` directory.
+    // which the `Add new` test below already rejects. A filter here would have to
+    // match on the PATH column instead, and would skip a real row whose path
+    // begins with a `File/` directory.
     if (!/^add new$/i.test(tag)) continue;
     rows.push(path);
   }

package/pipeline/scripts/run-aggregator.mjs

@@ -87,8 +87,8 @@ function die(msg) {
 // Path resolution lives in _run-paths.mjs: tracker-state.json is written to
 // the flat <root>/<task-id>/ while agent-state.json documents the nested
 // <root>/<project>/<task-id>/, and both layouts are populated in practice.
-// This used to be a hand-rolled candidate list here, a second one in
-// render-cost-summary.sh and a third in render-agent-log-cost.sh.
+// Resolved once here rather than as a hand-rolled candidate list in each of
+// render-cost-summary.sh and render-agent-log-cost.sh as well.
 function resolveTrackerCandidates() {
   const candidates = [];
   if (flags["task-dir"]) {

package/pipeline/scripts/runs-index.mjs

@@ -44,9 +44,9 @@ import { invokedDirectly } from "../lib/invoked-directly.mjs";
 
 /**
  * The phase from which a run counts as "waiting on you", read from the phase
- * contract rather than written here. This threshold moved once already (it was
- * 6 under the eight-phase contract, it is 4 under six) and nothing connected it
- * to the renumbering, so it would have silently regrouped every run.
+ * contract rather than written here. The threshold follows the phase count (6
+ * under an eight-phase contract, 4 under six), so a literal would survive a
+ * renumbering unchanged and silently regroup every run.
  */
 const PHASE_WAITING_FROM = JSON.parse(
   readFileSync(new URL("../schemas/phases.json", import.meta.url), "utf8"),
@@ -203,10 +203,10 @@ export function buildIndex() {
       salvaged: Boolean(statePath && statePath.includes(`${run.dir}/artifacts/`)),
       // What KIND of record this is, before asking whether it is healthy.
       //
-      // 74 of the 103 runs on this machine have a tracker file and no agent
-      // state, and the first version of this index called every one of them
-      // `stateReadable: false` - so a panel built on it announced "74 runs
-      // could not be read" about records that are not damaged and never had
+      // A run with a tracker file and no agent state is the common case, not
+      // damage: most runs on a machine are shaped that way. Calling them
+      // `stateReadable: false` makes a panel announce "N runs could not be
+      // read" about records that are intact and never had
       // agent state to begin with. `/multi-agent:analysis` says so in its own
       // description ("no worktree, no commits, no dev chain"), and design-check
       // is the same shape.

package/pipeline/scripts/scope-check-gate.mjs

@@ -4,7 +4,7 @@
  *
  * Phase 3 writes `.pipeline/scope-check.json` before the handoff: one reason
  * per touched file, the things it deliberately did not do, and the simplifier
- * rationales that used to be discarded. This gate compares that record with
+ * rationales that are otherwise discarded. This gate compares that record with
  * the real diff so an unjustified file cannot ride into review unnoticed.
  *
  * Usage:

package/pipeline/scripts/smoke-schema-validation.sh

@@ -26,11 +26,10 @@ LIVE_PREFS="$HOME/.claude/multi-agent-preferences.json"
 
 # The migration target, derived the way migrate-prefs.mjs derives it: the last
 # entry of the schema's schemaVersion enum, read from the schema that sits
-# beside the migrator being checked. It used to be grepped as a
-# `TARGET_VERSION = "x.y.z"` literal out of the migrator, and when that literal
-# was replaced by the schema read - precisely because a literal had drifted a
-# minor behind - the grep started matching nothing and both checks that depend
-# on it reported "no reference point". A gate that reads the source of truth
+# beside the migrator being checked. Not grepped as a `TARGET_VERSION = "x.y.z"`
+# literal out of the migrator: a literal drifts, and the moment it is replaced by
+# a schema read the grep matches nothing and both checks that depend on it report
+# "no reference point". A gate that reads the source of truth
 # cannot go stale against it; a gate that reads a transcription of it can.
 migration_target() {
   local schema="$1/../schemas/prefs.schema.json"
@@ -213,15 +212,13 @@ if [ -f "$LIVE_PREFS" ]; then
 
   # The target is read from migrate-prefs.mjs, never hardcoded here.
   #
-  # This block used to say `if [ "$LVER" = "2.1.0" ]; then pass "already v2.1.0"`
-  # with everything else falling through to `fail "unknown schemaVersion"`. The
-  # migration target had since moved to 2.4.0, which inverted the gate: a prefs
-  # file left behind at 2.1.0 reported PASS as "already current", while a file
-  # correctly migrated to 2.4.0 hit the else arm and FAILED as "unknown". The
-  # gate was rejecting the only fully-migrated state it exists to encourage.
+  # A hardcoded version here inverts the gate the moment the migration target
+  # moves: the stale version passes as "already current" and the correctly
+  # migrated one falls through to "unknown schemaVersion", so the gate rejects
+  # the only fully-migrated state it exists to encourage.
   #
   # Reading the target and the accepted set from the same schema enum the
-  # migrator reads means this can never disagree with it again.
+  # migrator reads means this cannot disagree with it.
   MIGRATOR="$SMOKE_DIR/migrate-prefs.mjs"
   TARGET=$(migration_target "$(dirname "$MIGRATOR")")
   KNOWN=$(node -e "

package/pipeline/scripts/usage-report.mjs

@@ -612,11 +612,11 @@ if (invokedDirectly) {
   // Exit 0 stays: usage telemetry must never be the reason a run fails, and a
   // non-zero exit here would propagate into whatever called it.
   //
-  // But the silence goes. `catch(() => process.exit(0))` reported success for
-  // every failure, so a telemetry path that had been broken for weeks looked
-  // exactly like one that worked - there was no surface on which anyone could
-  // notice. One line on stderr costs nothing and is the difference between a
-  // degraded feature and an invisible one.
+  // But the silence goes. A bare `catch(() => process.exit(0))` reports success
+  // for every failure, so a broken telemetry path looks exactly like one that
+  // works and there is no surface on which to notice it. One line on stderr
+  // costs nothing and is the difference between a degraded feature and an
+  // invisible one.
   main().catch((err) => {
     process.stderr.write(`usage-report: not sent  -  ${err?.message ?? err}\n`);
     process.exit(0);

package/pipeline/scripts/validate-analysis-doc.mjs

@@ -935,10 +935,10 @@ function main() {
 
   mark("placeholder-bodies", profile === "global" ? undefined : "corporate profile");
 
-  // 4b. Locked 2's numbering half, which was ungated until v19.0.0.
+  // 4b. Locked 2's numbering half.
   //
-  // It is NOT "numbering re-flows 1..N". That is what the rule used to say and
-  // it could not hold: Locked 30 threads ids across the document by section
+  // It is NOT "numbering re-flows 1..N", which could not hold: Locked 30
+  // threads ids across the document by section
   // NUMBER ("Section 15.1 scenario", "Section 4.4", "Section 3/5 layout cells"),
   // so a re-flowed document sends every one of those references to the wrong
   // section. No emitted document ever re-flowed. The rule was the wrong half.

package/pipeline/scripts/write-state.mjs

@@ -40,6 +40,9 @@
  *   WRITE_STATE_LOCK_ABANDON_MS  ceiling past which even a lock that probes as
  *                                alive is reclaimed, covering PID reuse
  *                                (default: 10x STALE_MS)
+ *   WRITE_STATE_TEST_DELAY_MS    test seam: pause between acquiring the lock
+ *                                and the write, so the exit-4 refusal can be
+ *                                driven on purpose (default 0, off)
  * A dead holder (PID no longer alive) is reclaimed immediately regardless of
  * age. A live holder keeps its lock: liveness outranks age. See
  * lockIdentityIfStale() for why that order is load-bearing.
@@ -109,11 +112,11 @@ async function acquireLock(
   const staleMs = Number(process.env.WRITE_STATE_LOCK_STALE_MS) || 30_000;
   const deadline = Date.now() + timeoutMs;
   // The lock file must never be observable without its owning PID inside it.
-  // It used to be created with openSync(wx) and filled on the next line, so
-  // between those two calls it existed and was empty. A writer arriving in
-  // that window read an unparseable PID, concluded the lock was stale, and
-  // deleted a live one - after which two writers held it and one write was
-  // lost. Under CPU load that reproduced 3 times in 15 runs.
+  // Created with openSync(wx) and filled on the next line, it exists and is
+  // empty between those two calls. A writer arriving in that window reads an
+  // unparseable PID, concludes the lock is stale, and deletes a live one -
+  // after which two writers hold it and one write is lost. The window is only
+  // wide enough to hit under CPU load, which is where it matters.
   //
   // Writing the PID into a private temp file and hard-linking it into place
   // closes the window: link() fails with EEXIST if the lock is held, and the
@@ -141,8 +144,8 @@ async function acquireLock(
       // deleting it, the holder can release and a THIRD writer can acquire a
       // fresh one - and an unlink by path deletes that live lock, after which
       // two writers hold it and one update is lost. Same failure the PID window
-      // above once caused, at a different point in the loop; it survived because
-      // it only reproduces under load, where the gap is wide enough to lose.
+      // above describes, at a different point in the loop, and it only reproduces
+      // under load, where the gap is wide enough to lose.
       //
       // The inode is the identity: a newly acquired lock is a different file
       // even at the same path. Delete only if the file we judged is still the
@@ -176,10 +179,10 @@ async function acquireLock(
  * A lock is stale when its owning PID is no longer alive. Age alone is not
  * staleness.
  *
- * The order here is the whole point. Age used to be checked first and returned
- * "stale" on its own, so a holder that was demonstrably ALIVE lost its lock the
- * moment the file passed 30 seconds - and the next writer then deleted a live
- * lock and overwrote the update behind it. Liveness is direct evidence;
+ * The order here is the whole point. Checking age first and returning "stale" on
+ * its own costs a holder that is demonstrably ALIVE its lock the moment the file
+ * passes 30 seconds - and the next writer then deletes a live lock and overwrites
+ * the update behind it. Liveness is direct evidence;
  * a timestamp is a guess about it, and a guess must not overrule the evidence.
  *
  * Age survives for the one case liveness cannot answer: PID reuse. A dead
@@ -330,6 +333,14 @@ async function main() {
   try {
     heldLockIno = await acquireLock(path);
     heldLockFor = path;
+    // Test seam. The refusal below is the one path that cannot be reached on
+    // demand: it needs another writer to take the lock inside the window
+    // between acquiring it and renaming, which on an idle machine is too
+    // narrow to hit and on a loaded one is a coin flip. A gate that can only
+    // observe this path by accident is not holding it. Unset in every real
+    // run; the whole seam is one sleep.
+    const testDelayMs = Number(process.env.WRITE_STATE_TEST_DELAY_MS) || 0;
+    if (testDelayMs > 0) await new Promise((r) => setTimeout(r, testDelayMs));
   } catch (err) {
     if (err.code === "LOCK_TIMEOUT") {
       console.error(err.message);

package/pipeline/skills/.skill-manifest.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-09-21T06:17:16Z",
+  "generatedAt": "2026-09-21T08:28:08Z",
   "skillCount": 216,
   "entries": [
     {
@@ -45,7 +45,7 @@
     },
     {
       "path": "shared/core/multi-agent-channels/SKILL.md",
-      "sha256": "414eead38b461c8aa95f6af3175366be905338233e6872313f5d4f59a02351af"
+      "sha256": "e4f59e784d77018326e719632ef371e50e9fb9af61318a7d5bf713c386c0fd3f"
     },
     {
       "path": "shared/core/multi-agent-complaint-analysis/SKILL.md",
@@ -253,7 +253,7 @@
     },
     {
       "path": "shared/core/multi-agent/SKILL.md",
-      "sha256": "9ab7af2ffb01f8eb0fae624ae40ea9ff2f6d69ad61544bd266b1b97f60eb4a0f"
+      "sha256": "7ea676d07cd0104cc929b825463c521aff66047c6dcdfc28e9e37ca3752107da"
     },
     {
       "path": "shared/external/accessibility-compliance-accessibility-audit/SKILL.md",

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

@@ -708,5 +708,5 @@ When `multi-agent status` is called, show:
 ## Help Display
 
 Rendered by the `multi-agent-help` skill (`/multi-agent:help`), which owns
-the full text in both languages. It used to be duplicated here in English
-only, on a path this skill takes for exactly one input.
+the full text in both languages. Duplicating it here would mean English only,
+on a path this skill takes for exactly one input.

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

@@ -152,11 +152,10 @@ h2. Bağlantılar
 Reproduction scenarios first, then regressions for whatever the change could
 have disturbed. Full contract: `channels/jira.md`.
 
-`{{file.ext → func}}`, `*Root cause:*` and `*Changed files:*` used to be this
-template. They are gone deliberately: that shape put a hash-table mutation
-walk in front of a tester, and `{{file → func}}` is exactly where a Swift
-selector like `hash(into:)` ends up - whose trailing `:)` Jira renders as a
-smiley.
+`{{file.ext → func}}`, `*Root cause:*` and `*Changed files:*` are deliberately
+NOT this template. That shape puts a hash-table mutation walk in front of a
+tester, and `{{file → func}}` is exactly where a Swift selector like
+`hash(into:)` ends up - whose trailing `:)` Jira renders as a smiley.
 
 **Post through the publisher, never a hand-rolled `curl`:**