@mmerterden/multi-agent-pipeline 16.14.0 → 16.16.0

package/pipeline/commands/multi-agent/steer/SKILL.md

@@ -0,0 +1,109 @@
+---
+description: "Queue an instruction for a task that is already running. It is applied at the next phase boundary, not mid-phase. Use when a run is going the wrong way and killing it would throw away good work."
+description-tr: "Zaten koşmakta olan bir göreve talimat bırakır. Talimat faz ortasında değil, bir sonraki faz sınırında uygulanır. Koşu yanlış yöne gidiyorsa ve kill etmek iyi işi de çöpe atacaksa kullanılır."
+argument-hint: "#id \"<instruction>\"  -  e.g. #3 \"the field is called web, not frontend\". With no instruction, you are asked for it."
+---
+
+# multi-agent steer  -  correct a run without stopping it
+
+**Input**: $ARGUMENTS
+
+Leave one instruction for a running task. The next phase reads it before it
+starts work, applies it, and marks it consumed.
+
+This exists because the alternative was losing the run. `kill` stops a task and
+deletes its worktree; `resume` picks a stopped one back up. Neither helps while
+a phase is in flight, so a correction that arrived mid-run - "that field is
+called `web`, not `frontend`", "keep the analysis, drop the rest" - had nowhere
+to go, and the run carried on in the wrong direction until it finished.
+
+**Not a second prompt.** One instruction is queued at a time. Steering a task
+that already has an unconsumed instruction replaces it, after showing you what
+is being replaced.
+
+## Steps
+
+1. **Find the task**  -  parse `#N` or `{JIRA-KEY}-XXXXX` from the argument,
+   the same way `kill` and `resume` do. Locate its `agent-state.json`:
+
+   ```bash
+   find {repo}/.worktrees/ -name "agent-state.json" -maxdepth 2
+   find $HOME/.claude/logs/multi-agent -maxdepth 4 -name agent-state.json -path '*/artifacts/*'
+   ```
+
+   Not found → `ERR: no task #N. '/multi-agent:status' lists what is running.`
+
+2. **Check it can still be steered**  -  read `status` and `currentPhase`:
+
+   | State | What to do |
+   |---|---|
+   | `in_progress` | Queue it. This is the case the command is for. |
+   | `paused` / `failed` | Say the task is not running, and that `/multi-agent:resume #N` will re-enter with the instruction applied at that phase's entry. Queue it. |
+   | `complete` | Refuse. Nothing will read it. Point at `/multi-agent` for a follow-up run. |
+
+   `currentPhase` is 7 and status is `in_progress` → warn that Phase 7 is the
+   last one, so an instruction queued now may never be consumed.
+
+3. **Read the instruction**  -  from the argument, or ask for it when the
+   argument carries only an id. Verbatim, up to 4000 characters. Do not
+   summarize or rewrite it: the phase that consumes it needs the user's own
+   words, and a paraphrase is where the meaning goes.
+
+4. **Show what will be queued, and ask**:
+
+   ```
+   Steer #3 ({JIRA-KEY}-12345, Phase 3 Dev, in_progress)
+
+     "the field is called web, not frontend"
+
+   Applied at the entry to Phase 4. The current phase finishes as it is.
+   ```
+
+   Already carrying an unconsumed `pendingSteer` → print the old text above the
+   new one and ask whether to replace it.
+
+5. **Write it**  -  through the state writer, never by editing the file, because
+   the running task is writing to it too. `$STATE_FILE` is the path from step 1
+   and `$INSTRUCTION` the text from step 3:
+
+   ```bash
+   printf '{"pendingSteer":{"text":%s,"at":"%s","appliedAt":null,"appliedPhase":null}}' \
+     "$(node -e 'process.stdout.write(JSON.stringify(process.argv[1]))' "$INSTRUCTION")" \
+     "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+     | node $HOME/.claude/scripts/write-state.mjs "$STATE_FILE"
+   ```
+
+   The instruction is JSON-encoded by `node -e`, not by hand: it is arbitrary
+   user text, and a quote or newline in it would otherwise produce invalid JSON
+   or, worse, a payload that merges into fields nobody meant to touch.
+
+   Exit 2 (lock timeout) → the task is mid-write. Retry once, then report it
+   rather than forcing the write.
+
+6. **Confirm**: `🧭 Steer queued for #N  -  applies at the entry to Phase {N+1}`
+
+## What the phase does with it
+
+Phase entry, before any work: read a `pendingSteer` that has no `appliedAt`.
+When present, apply it to that phase's context, set `appliedAt` and
+`appliedPhase` - which is what stops it being read a second time - and write a
+`Steer applied` line into `agent-log.md`. The record itself stays, so the run
+keeps the trace of what was asked and when. The contract lives in
+`$HOME/.claude/multi-agent-refs/phases.md` under "Phase entry  -  pending
+steer" (the file has a second, unrelated "Phase entry" line inside the tracker
+block).
+
+Applied at entry rather than the moment it arrives, on purpose: a phase that
+changes target halfway through throws away the work it already did, which is
+the outcome this command exists to avoid.
+
+An instruction that contradicts the plan is not silently obeyed. The phase says
+what it is changing, and a contradiction that would invalidate an approved plan
+halts for the user instead of quietly rewriting it.
+
+**One limit worth knowing.** The reader is the phase contract, so a task started
+by an install that predates it will not consume the field: the instruction is
+written and nothing picks it up. There is no version stamp on a state file to
+detect this from, so the honest advice is that steer applies to runs started
+after the install carrying it. A run already in flight from an older install is
+still a `kill` or a wait.

package/pipeline/commands/multi-agent/sync/SKILL.md

@@ -59,7 +59,7 @@ Run every step automatically:
 ```
 Step 1: PLATFORM    Detect macOS / Linux / Windows (Git Bash / WSL); export PLATFORM env
 Step 1.5: DETECT    Compare timestamps, find stale targets
-Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 54 sub-command skills)
+Step 2: COPILOT     Claude Code -> Copilot CLI (instructions + 55 sub-command skills)
 Step 2b: CODEX      Claude Code -> Codex CLI (1 router skill + 51 specs as refs + 8 agent TOML)
 Step 3: REPO        Claude Code -> pipeline repo (genericized, personal data scrub, bash -n on all sh)
 Step 3c: PLUGINS    pipeline shared/external -> multi-agent-plugins marketplace (rebuild knowledge/,
@@ -166,7 +166,7 @@ If nothing is stale → report "All targets up to date" and stop.
 Unlike the Copilot step, this one does **not** hand-copy files. The Codex tree is a
 *transform* of the Claude tree, not a mirror of it, and the transform is real work:
 
-- the 54 sub-command specs become reference files, because Codex silently truncates
+- the 55 sub-command specs become reference files, because Codex silently truncates
   its skills block (see `cross-cli-contract.md` 2.6 for the measurement)
 - every `$HOME/.claude/...` reference to a CLI-owned tree is retargeted, with
   `agents/<persona>.md` becoming `.toml` and the dispatcher becoming the router skill
@@ -479,17 +479,15 @@ When invoked with the `release` argument:
 
 ## Sub-Command Sync (Claude Code <-> Copilot CLI Skills)
 
-> Codex takes the Step 2b path instead; see that section.
-
 This runs on the Claude <-> Copilot axis. Codex is NOT synced here: it receives the
-same 51 specs as reference files rather than as peer skills, via Step 2b -  see
+same 55 specs as reference files rather than as peer skills, via Step 2b -  see
 `cross-cli-contract.md` 2.6 for why the parity axis differs per host.
 
 | Claude Code | Copilot CLI |
 |-------------|-------------|
 | `~/.claude/commands/multi-agent/{cmd}/SKILL.md` | `~/.copilot/skills/multi-agent-{cmd}/SKILL.md` |
 
-**54 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
+**55 commands are synced** (canonical inventory  -  must match `cross-cli-contract.md` section 1; drift = contract violation):
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels,
@@ -498,7 +496,7 @@ dev-local-autopilot, diff-explain, feedback, forget, garbage-collect,
 graph, help, ios-coding-standard, issue, jira, kill, language, local,
 local-autopilot, log, manual-test, prune-logs, prune-prompts, purge,
 refactor, resume, resume-local, review, review-analysis, review-issue,
-review-jira, routines, save, scan, search, setup, stack, status,
+review-jira, routines, save, scan, search, setup, stack, status, steer,
 store-ready, sync, test, test-accessibility, test-dark-mode,
 test-dynamic-type, test-screenshots, testflight-validation, uninstall, update
 ```

package/pipeline/multi-agent-refs/cross-cli-contract.md

@@ -6,7 +6,7 @@
 
 ---
 
-## 1. Command Inventory (54 files, 50 live commands)
+## 1. Command Inventory (55 files, 51 live commands)
 
 ```
 analysis, analysis-resolve, autopilot, build-optimize, channels,
@@ -15,7 +15,7 @@ dev-local-autopilot, diff-explain, feedback, forget, garbage-collect,
 graph, help, ios-coding-standard, issue, jira, kill, language, local,
 local-autopilot, log, manual-test, prune-logs, prune-prompts, purge,
 refactor, resume, resume-local, review, review-analysis, review-issue,
-review-jira, routines, save, scan, search, setup, stack, status,
+review-jira, routines, save, scan, search, setup, stack, status, steer,
 store-ready, sync, test, test-accessibility, test-dark-mode,
 test-dynamic-type, test-screenshots, testflight-validation, uninstall, update
 ```
@@ -27,12 +27,12 @@ Categories:
 - **Pipeline entries**: `autopilot`, `local`, `local-autopilot` (plus the bare `/multi-agent` in the dispatcher). Depth is not a command: `/multi-agent` and `local` ask Full or Short at Phase 0 Step 7.5; the two autopilot entries never ask and always run Full.
 - **Retired stubs** (v16.0.0, deleted next minor  -  they print a redirect and run no phase): `dev`, `dev-local` redirect to the picker entries with Short; `dev-autopilot`, `dev-local-autopilot` have no equivalent, because fast-plus-unattended no longer exists
 - **Tail modes** (run the pipeline tail over already-done local work): `resume-local`
-- **Ops commands** (one-shot, no worktree): `status`, `log`, `kill`, `purge`, `uninstall`, `resume`, `review`, `review-jira`, `review-issue`, `analysis`, `analysis-resolve`, `complaint-analysis`, `build-optimize`, `channels`, `scan`, `search`, `diff-explain`, `garbage-collect`, `graph`, `prune-logs`, `prune-prompts`
+- **Ops commands** (one-shot, no worktree): `status`, `log`, `kill`, `steer`, `purge`, `uninstall`, `resume`, `review`, `review-jira`, `review-issue`, `analysis`, `analysis-resolve`, `complaint-analysis`, `build-optimize`, `channels`, `scan`, `search`, `diff-explain`, `garbage-collect`, `graph`, `prune-logs`, `prune-prompts`
 - **Local audits** (worktree only to build; no commit, push, PR or channels): `design-check`, `testflight-validation`, `ios-coding-standard`. `testflight-validation` additionally never invokes `altool --upload-app`  -  a validation run must not be able to ship a build by accident.
 - **Meta-ops**: `setup`, `sync`, `update`, `help`, `refactor`, `test`, `stack`, `manual-test`, `language`
 - **Routines** (user-defined routine registry; the routines they create are local-only and never synced): `save`, `routines`, `forget`
 
-The count is 54 files and 50 live commands until the four stubs are deleted, at which point both numbers become 50. A stub is still installed and still invocable, so counting it as absent would be wrong; counting it as a command would be worse.
+The count is 55 files and 51 live commands until the four stubs are deleted, at which point both numbers become 51. A stub is still installed and still invocable, so counting it as absent would be wrong; counting it as a command would be worse.
 
 > **Inventory drift is a contract violation.** Adding a slash command under `pipeline/commands/multi-agent/` without updating this list + its counterpart Copilot dir (`pipeline/skills/shared/core/multi-agent-<cmd>/`) is a merge blocker. `smoke-commands-skills-parity.sh` enforces command ↔ skill directory parity; `smoke-cross-cli-behavior.sh` enforces behavior parity. This doc is the authoritative command list  -  bump the count + table together.
 

package/pipeline/multi-agent-refs/phases/operations.md

@@ -95,6 +95,29 @@ halt per the halt-visibility rule), `3` I/O error.
 Reads need no wrapper; the rename makes any read see either the old or the new
 document, never a truncated one.
 
+**`rev`, and reading before writing back.** Every successful write bumps
+`state.rev`, a counter that only increases. It exists because a read and the
+write that follows it are not one operation. The lock above makes a single write
+atomic and nothing more; the concurrent worktrees named there, and
+`/multi-agent:steer`, which writes into the state file of a task that is still
+running, both land inside the gap between a phase's read and its write-back.
+
+A phase that will write back what it read keeps the `rev` it read, re-reads
+immediately before writing, and re-derives its patch when the number has moved.
+`write-state.mjs` takes the higher of the on-disk `rev` and the one in the
+incoming patch, so a stale patch can never walk the counter backwards - but that
+only protects the counter, not the fields. Deciding what to do about a
+concurrent change is the caller's job.
+
+A record written before `rev` existed has none: treat a missing `rev` as 0.
+
+**Stale locks: liveness outranks age.** A lock is reclaimed when its holder PID
+is no longer alive. A holder that is alive keeps its lock however old the file
+is - the reverse order (age first) is what let a writer delete a live lock and
+lose the update behind it. `WRITE_STATE_LOCK_STALE_MS` now applies only to a
+lock with no readable PID, and `WRITE_STATE_LOCK_ABANDON_MS` (default ten times
+that) is the last-resort ceiling for a PID that has been recycled.
+
 **Halt visibility (required, autopilot included).** A halt is never silent. Whenever a phase halts on a hard error (validator failed twice, no subagent returned, dispatch error past fallback, lock irrecoverable), in addition to the `agent-log.md` line: (a) write `state.status = "paused"` and `state.haltReason = "<phase>:<cause>"`; (b) record the cause on the tracker via `phase-tracker.sh meta <phase> halt "<cause>"` and `phase-tracker.sh update <phase> failed`; (c) emit one `>&2` alert line `HALT phase <N>: <cause>  -  resume with /multi-agent:resume #<id>`; (d) if `prefs.global.usageLog.enabled` is true, emit the end-of-run report so a run that never reaches Phase 7 is still recorded with the phase it stopped at (`state.currentPhase` + `haltReason`) - the emitter no-ops when it is off or unconfigured:
 
 ```bash

package/pipeline/multi-agent-refs/phases/phase-0-init.md

@@ -631,8 +631,12 @@ Phase 0 owns `agent-state.json`. Do not call
 
 ```bash
 node "$HOME/.claude/scripts/phase0-exit-gate.mjs" "$TASK_ID" --input "$ORIGINAL_INPUT"
+node "$HOME/.claude/scripts/usage-report.mjs" --task-id "$TASK_ID" >/dev/null 2>&1 || true
 ```
 
+The second line reports the run as started: reporting only from Phase 7 reported
+only runs that finish, and few do. Phase 7 upserts the same key over it.
+
 It asserts three things, each of which has failed silently in a real run:
 
 1. **`agent-state.json` exists.** A run once reported Phase 0 `completed` with only

package/pipeline/multi-agent-refs/phases/phase-7-report.md

@@ -196,7 +196,7 @@ $HOME/.claude/scripts/log-metric.sh "$TASK_ID" 7 task.completed \
   duration_ms=$TOTAL_DURATION
 ```
 
-**Operational reporting.** On by default since v16.8.0; `enabled: false` or `optOut: true` silences it. Sends command, duration, tokens, outcome - never a repo name or path. One POST per run, fire-and-forget, coarse run metadata only  -  no prompts, code, diffs, or absolute paths. The script no-ops when `usageLog.enabled` is not true or no token resolves, so the call is unconditional and never blocks the run.
+**Operational reporting.** On by default since v16.8.0; `enabled: false` or `optOut: true` silences it. Coarse run metadata only, never prompts, code, diffs, repo names or paths. Fire-and-forget: it no-ops without a token and never blocks the run, so the call is unconditional. Phase 0 already reported this run as started; this upserts the final state over it.
 
 ```bash
 node $HOME/.claude/scripts/usage-report.mjs --state "$STATE_FILE" >/dev/null 2>&1 || true

package/pipeline/multi-agent-refs/phases.md

@@ -26,6 +26,44 @@ Short:     0-Init -> (1,2 skipped) --------------> 3-Dev -> 4-Review -> 5-Test -
 Full or Short is the Phase 0 Step 7.5 question, not a command name. Autopilot never asks and always runs Full.
 ```
 
+## Phase entry  -  pending steer (every phase, every mode)
+
+Before a phase does any work, read `pendingSteer` from `agent-state.json`. It
+is how a correction reaches a run that is already going: `/multi-agent:steer #N
+"<instruction>"` queues one, and the next phase to start consumes it.
+
+```bash
+STEER=$(node -e 'try{const s=require(process.argv[1]);const p=s.pendingSteer;if(p&&p.text&&!p.appliedAt)process.stdout.write(p.text)}catch{}' "$STATE_FILE")
+```
+
+The `catch` is not decoration: a state file that does not exist yet (Phase 0
+before its first write) makes `require` throw, and an unguarded read prints a
+stack trace at every phase entry that reads like a failed phase.
+
+Empty → carry on, nothing to do. Non-empty:
+
+1. Apply it to this phase's context before starting. It is the user's own
+   words; treat it as an instruction from them, arriving now.
+2. Say what changed, in one line, so the correction is visible in the run and
+   not only in the state file.
+3. Mark it consumed. The record stays as a trace; `appliedAt` is what stops it
+   being read again, and the next steer overwrites all four keys:
+   ```bash
+   printf '{"pendingSteer":{"appliedAt":"%s","appliedPhase":<N>}}' "$(date -u +%Y-%m-%dT%H:%M:%SZ)" \
+     | node $HOME/.claude/scripts/write-state.mjs "$STATE_FILE"
+   ```
+
+   `<N>` is this phase's number, substituted literally and unquoted - it is a
+   JSON number. Leaving it as an unset shell variable produces
+   `"appliedPhase":}`, which is invalid JSON and exits 1.
+4. Record it on the tracker and in the log: `bash $HOME/.claude/scripts/phase-tracker.sh meta <N> steer "applied"`, plus a `Steer applied: <text>` line in `agent-log.md`.
+
+Two limits, both deliberate. It is read at phase **entry** only, never mid-phase:
+a phase that changes target halfway discards the work it already did, which is
+the outcome steer exists to avoid. And an instruction that contradicts an
+approved plan halts for the user rather than silently rewriting the plan -
+steering corrects a run, it does not re-authorize one.
+
 ## Visual Phase Tracker
 
 Two channels run in parallel at every phase boundary. Both are required in their target CLIs  -  skipping either is the #1 source of "I see no progress" complaints.

package/pipeline/preferences-template.json

@@ -48,12 +48,7 @@
       "autoDiff": false,
       "manualNote": false
     },
-    "wikiScope": [
-      "main",
-      "ios",
-      "screenshots",
-      "index"
-    ],
+    "wikiScope": ["main", "ios", "screenshots", "index"],
     "autopilotReportTimeoutSeconds": 1800,
     "promptLanguage": "en",
     "outputLanguage": "en",
@@ -185,10 +180,7 @@
       "localPath": "plugins/<my-plugin>/skills/workflow",
       "upstreamMarketplace": "<installed-marketplace-name>",
       "upstreamPlugin": "<upstream-plugin-name>",
-      "upstreamSkills": [
-        "<skill-a>",
-        "<skill-b>"
-      ],
+      "upstreamSkills": ["<skill-a>", "<skill-b>"],
       "derivedFromVersion": "0.0.0",
       "upstreamVersionSource": "marketplace.json",
       "upstreamLocalClone": "$HOME/<upstream-repo-working-copy>",

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

@@ -21,6 +21,6 @@ available. Read the effective `enabledPlugins` and load each enabled toolkit's
 `ai-common-toolkit` and `ai-analyst-toolkit` are on everywhere. Nothing enabled
 is a normal state.
 
-**multi-agent-toolkit MCP.** 83 tools for a running app: `ui-inspect`,
+**multi-agent-toolkit MCP.** 80+ tools for a running app: `ui-inspect`,
 `crash-logs`, `design-check`, `ios-app-store-audit`, `ios-testflight`. Use them
 instead of guessing about on-screen state. Not registered is a silent no-op.

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

@@ -104,6 +104,41 @@
       "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'."
     },
+    "rev": {
+      "type": "integer",
+      "minimum": 0,
+      "description": "Monotonic revision, bumped by write-state.mjs on every successful write. A reader keeps the rev it read and compares before writing back; a changed rev means the record moved underneath it. Optional, so a record written by an earlier version stays valid: treat a missing rev as 0. No schemaVersion bump - the field is additive and nothing needs migrating."
+    },
+    "pendingSteer": {
+      "type": ["object", "null"],
+      "additionalProperties": false,
+      "required": ["text", "at"],
+      "description": "A mid-run instruction from the user, waiting for the next phase boundary to consume it. Written by /multi-agent:steer; a phase consumes it at entry by setting appliedAt, which is what stops it being read again. The record is kept as a trace and overwritten wholesale by the next steer. Never applied mid-phase: changing the target of work already in flight throws that work away.",
+      "properties": {
+        "text": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 4000,
+          "description": "The instruction, verbatim as the user typed it."
+        },
+        "at": {
+          "type": "string",
+          "format": "date-time",
+          "description": "When it was queued."
+        },
+        "appliedAt": {
+          "type": ["string", "null"],
+          "format": "date-time",
+          "description": "When a phase consumed it. Set alongside clearing the record, so the log keeps the trace."
+        },
+        "appliedPhase": {
+          "type": ["integer", "null"],
+          "minimum": 0,
+          "maximum": 7,
+          "description": "The phase that consumed it."
+        }
+      }
+    },
     "telemetry": {
       "type": "object",
       "additionalProperties": true,

package/pipeline/schemas/analysis-spec.schema.json

@@ -104,7 +104,10 @@
     "platforms": {
       "type": "array",
       "minItems": 1,
-      "items": { "type": "string", "enum": ["ios", "android", "web", "backend", "mobile", "frontend"] },
+      "items": {
+        "type": "string",
+        "enum": ["ios", "android", "web", "backend", "mobile", "frontend"]
+      },
       "description": "Platforms selected in Phase 0 step 3 (multi-select)."
     },
     "repos": {
@@ -114,7 +117,10 @@
         "additionalProperties": false,
         "required": ["platform", "name", "canPush"],
         "properties": {
-          "platform": { "type": "string", "enum": ["ios", "android", "web", "backend", "mobile", "frontend"] },
+          "platform": {
+            "type": "string",
+            "enum": ["ios", "android", "web", "backend", "mobile", "frontend"]
+          },
           "name": { "type": "string", "minLength": 1 },
           "cloneUrl": { "type": ["string", "null"] },
           "canPush": { "type": "boolean" }

package/pipeline/schemas/conventions-output.schema.json

@@ -66,13 +66,7 @@
     "conventionBucket": {
       "type": "object",
       "additionalProperties": false,
-      "required": [
-        "pattern",
-        "example",
-        "confidence",
-        "evidenceFiles",
-        "alternativeCandidates"
-      ],
+      "required": ["pattern", "example", "confidence", "evidenceFiles", "alternativeCandidates"],
       "properties": {
         "pattern": {
           "type": "string",
@@ -84,12 +78,7 @@
         },
         "confidence": {
           "type": "string",
-          "enum": [
-            "high",
-            "medium",
-            "low",
-            "none"
-          ],
+          "enum": ["high", "medium", "low", "none"],
           "description": "high: 5+ examples; medium: 3-4; low: 1-2 or mixed; none: no evidence."
         },
         "evidenceFiles": {

package/pipeline/scripts/build-references.mjs

@@ -34,7 +34,7 @@ const NONE = "-";
 
 function argOf(argv, flag) {
   const i = argv.indexOf(flag);
-  return i === -1 ? null : argv[i + 1] ?? null;
+  return i === -1 ? null : (argv[i + 1] ?? null);
 }
 
 function readState(path) {
@@ -102,15 +102,27 @@ function rowsFrom(spec, lang) {
       c.url,
       ref || NONE,
       c.embeddedApiTable
-        ? lang === "tr" ? "API kontratı" : "API contract"
-        : lang === "tr" ? "özellik spesifikasyonu" : "feature spec",
+        ? lang === "tr"
+          ? "API kontratı"
+          : "API contract"
+        : lang === "tr"
+          ? "özellik spesifikasyonu"
+          : "feature spec",
       OK[lang],
       NONE,
     );
   }
 
   for (const j of ev.jira ?? []) {
-    push("Jira", j.id, j.url ?? NONE, NONE, lang === "tr" ? "ticket" : "ticket", OK[lang], j.summary);
+    push(
+      "Jira",
+      j.id,
+      j.url ?? NONE,
+      NONE,
+      lang === "tr" ? "ticket" : "ticket",
+      OK[lang],
+      j.summary,
+    );
   }
 
   for (const s of ev.swagger ?? []) {
@@ -266,13 +278,17 @@ function tableLocators(block) {
   const found = [];
   for (const line of block.split(/\r?\n/)) {
     if (!line.trim().startsWith("|")) continue;
-    const cells = line.split("|").slice(1, -1).map((c) => c.trim());
+    const cells = line
+      .split("|")
+      .slice(1, -1)
+      .map((c) => c.trim());
     if (cells.length < 3) continue;
     if (/^:?-{3,}:?$/.test(cells[0])) continue;
     const locator = cells[2];
     const source = cells[1];
     if (!locator) continue;
-    if (HEADER_CELLS.has(locator.toLowerCase()) && HEADER_CELLS.has(cells[0].toLowerCase())) continue;
+    if (HEADER_CELLS.has(locator.toLowerCase()) && HEADER_CELLS.has(cells[0].toLowerCase()))
+      continue;
     found.push({ locator, source, raw: line });
   }
   return found;

package/pipeline/scripts/code-graph-rules/android.json

@@ -3,19 +3,9 @@
   "stack": "android",
   "description": "Kotlin + Java code-graph rules. Adds what the graph needs on top of test-gap-rules/android.json, which already owns sourceExtensions, excludePathGlobs and the test-path predicates. Definition patterns here are deliberately broader than the test-gap publicApiPatterns: the graph wants internal types too, because Phase 1 narrows scope on the whole module, not just its public surface.",
   "comments": {
-    "line": [
-      "//"
-    ],
-    "block": [
-      [
-        "/*",
-        "*/"
-      ]
-    ],
-    "string": [
-      "\"\"\"",
-      "\""
-    ]
+    "line": ["//"],
+    "block": [["/*", "*/"]],
+    "string": ["\"\"\"", "\""]
   },
   "definitionPatterns": [
     {
@@ -60,14 +50,7 @@
       "regex": "^\\s*import\\s+(?:static\\s+)?(?:[A-Za-z_][A-Za-z0-9_]*\\.)+([A-Z][A-Za-z0-9_]*)"
     }
   ],
-  "referenceKinds": [
-    "class",
-    "interface",
-    "object",
-    "enum",
-    "record",
-    "typealias"
-  ],
+  "referenceKinds": ["class", "interface", "object", "enum", "record", "typealias"],
   "referenceKindsNote": "fun is deliberately absent, for the reason Swift's rules record for func: a bare lowercase name matched across files is almost never a call to that exact declaration, and on a large app the generic ones (invoke, build, create, get) take the top god-node slots purely because each happened to be declared once. Composables are the tempting exception - they are capitalised and behave like types - but they are declared with fun, so including them means including every other fun with them.",
   "ignoredIdentifiers": [
     "this",

package/pipeline/scripts/code-graph-rules/go.json

@@ -3,20 +3,9 @@
   "stack": "go",
   "description": "Go code-graph rules. Adds what the graph needs on top of test-gap-rules/go.json, which already owns sourceExtensions, excludePathGlobs and the test-path predicates. Definition patterns here are deliberately broader than the test-gap publicApiPatterns: the graph wants unexported declarations too, because Phase 1 narrows scope on the whole package, not just its exported surface.",
   "comments": {
-    "line": [
-      "//"
-    ],
-    "block": [
-      [
-        "/*",
-        "*/"
-      ]
-    ],
-    "string": [
-      "`",
-      "\"",
-      "'"
-    ]
+    "line": ["//"],
+    "block": [["/*", "*/"]],
+    "string": ["`", "\"", "'"]
   },
   "importSpecifiersAreStrings": true,
   "definitionPatterns": [
@@ -47,11 +36,7 @@
       "regex": "^[ \\t]*(?:import[ \\t]+)?(?:[A-Za-z_.][A-Za-z0-9_]*[ \\t]+)?\"(?:[^\"]*/)?([A-Za-z_][A-Za-z0-9_.-]*)\"[ \\t]*$"
     }
   ],
-  "referenceKinds": [
-    "struct",
-    "interface",
-    "type"
-  ],
+  "referenceKinds": ["struct", "interface", "type"],
   "referenceKindsNote": "func is deliberately absent, for the reason the Swift, Kotlin, Node and Python rules all record: a bare name matched across files is almost never a call to that exact declaration, and Go's short-name convention (New, Run, Get, Close, Error) makes it worse than most. Functions still reach the graph through their defines edge, so they stay findable by name.",
   "ignoredIdentifiers": [
     "package",

package/pipeline/scripts/code-graph-rules/node.json

@@ -3,20 +3,9 @@
   "stack": "node",
   "description": "TypeScript + JavaScript code-graph rules. Adds what the graph needs on top of test-gap-rules/node.json, which already owns sourceExtensions, excludePathGlobs and the test-path predicates. Definition patterns here are deliberately broader than the test-gap publicApiPatterns: the graph wants unexported declarations too, because Phase 1 narrows scope on the whole module, not just its public surface.",
   "comments": {
-    "line": [
-      "//"
-    ],
-    "block": [
-      [
-        "/*",
-        "*/"
-      ]
-    ],
-    "string": [
-      "`",
-      "\"",
-      "'"
-    ]
+    "line": ["//"],
+    "block": [["/*", "*/"]],
+    "string": ["`", "\"", "'"]
   },
   "definitionPatterns": [
     {
@@ -56,13 +45,7 @@
       "regex": "(?:\\bfrom|\\brequire\\s*\\(|\\bimport)\\s*\\(?\\s*[\"'](?:[^\"']*[\\/:])?([A-Za-z_$][A-Za-z0-9_$-]*)(?:\\.[A-Za-z0-9]+)*[\"']"
     }
   ],
-  "referenceKinds": [
-    "class",
-    "interface",
-    "type",
-    "enum",
-    "const"
-  ],
+  "referenceKinds": ["class", "interface", "type", "enum", "const"],
   "referenceKindsNote": "function is deliberately absent, for the reason Swift's rules record for func: a bare name matched across files is almost never a call to that exact declaration, and the generic ones (run, main, get, parse, handler) would take the top god-node slots purely because each happened to be declared once. Functions still reach the graph through their defines edge, so they stay findable by name. const is present but narrowed to an uppercase-initial declaration at column 0, which is what a component, a singleton or an exported table looks like; a lowercase const is a local and is not a declaration anyone references across files. Measured on this repo (126 sources): including function put `ok` at degree 52, `f` at 38, `tokens` at 15 and `arg` at 12 - local helper names that happen to be declared exactly once, so the ambiguity rule does not catch them either. Excluding it leaves a thin symbol layer, and that is the honest shape of this stack: a JavaScript module's exported unit is usually a function, so the useful graph here is the import graph between files. `graph-affected \"<file>.mjs\"` answers who imports a module, which is the question this stack actually gets asked.",
   "ignoredIdentifiers": [
     "this",

package/pipeline/scripts/feedback-send.mjs

@@ -115,7 +115,9 @@ function endpointAllowed(endpoint) {
 async function main() {
   const text = String(arg("--text", "") ?? "").trim();
   if (!text) {
-    process.stderr.write('usage: feedback-send.mjs --text "<message>" [--kind bug|idea|question]\n');
+    process.stderr.write(
+      'usage: feedback-send.mjs --text "<message>" [--kind bug|idea|question]\n',
+    );
     process.exit(2);
   }
   if (text.length > TEXT_MAX) {