@mmerterden/multi-agent-pipeline 20.8.1 → 20.8.2

package/pipeline/lib/confusables.json

@@ -1,36 +1,23 @@
 {
-  "_readme": "Characters a guard folds before matching, applied after NFKC. `strip` lists invisible characters that are removed. `map` sends a character that renders like an ASCII one to that ASCII character: the dash family, and the Cyrillic and Greek letters whose glyphs match Latin ones. Chosen from the Unicode confusables data for the letters and punctuation the guard rules use. Read by lib/normalize-text.mjs and scripts/agent-guard.py.",
-  "strip": [
-    "\u00ad",
-    "\u034f",
-    "\u061c",
-    "\u115f",
-    "\u1160",
-    "\u17b4",
-    "\u17b5",
-    "\u180e",
-    "\u200b",
-    "\u200c",
-    "\u200d",
-    "\u200e",
-    "\u200f",
-    "\u202a",
-    "\u202b",
-    "\u202c",
-    "\u202d",
-    "\u202e",
-    "\u2060",
-    "\u2061",
-    "\u2062",
-    "\u2063",
-    "\u2064",
-    "\u2066",
-    "\u2067",
-    "\u2068",
-    "\u2069",
-    "\u3164",
-    "\ufeff",
-    "\uffa0"
+  "_readme": "Characters a guard folds before matching, applied after NFKC. `stripRanges` lists the Default_Ignorable_Code_Point set as hex code point ranges (a single value or `FIRST-LAST`); every character in them is removed. `map` sends a character that renders like an ASCII one to that ASCII character: the dash family, the Cyrillic and Greek letters whose glyphs match Latin ones, and the compatibility letters and digits added after Unicode 13 whose NFKC form is ASCII, so a Python whose unicodedata predates them folds them the way Node does. Chosen from the Unicode confusables data for the letters and punctuation the guard rules use. Read by lib/normalize-text.mjs and scripts/agent-guard.py.",
+  "stripRanges": [
+    "00AD",
+    "034F",
+    "061C",
+    "115F-1160",
+    "17B4-17B5",
+    "180B-180F",
+    "200B-200F",
+    "202A-202E",
+    "2060-206F",
+    "3164",
+    "FE00-FE0F",
+    "FEFF",
+    "FFA0",
+    "FFF0-FFF8",
+    "1BCA0-1BCA3",
+    "1D173-1D17A",
+    "E0000-E0FFF"
   ],
   "map": {
     "\u2010": "-",
@@ -95,6 +82,65 @@
     "\u03b1": "a",
     "\u03bd": "v",
     "\u03c1": "p",
-    "\u0131": "i"
+    "\u0131": "i",
+    "\ua7f1": "S",
+    "\ua7f2": "C",
+    "\ua7f3": "F",
+    "\ua7f4": "Q",
+    "\ud801\udf81": ":",
+    "\ud801\udfa5": "q",
+    "\ud833\udcd6": "A",
+    "\ud833\udcd7": "B",
+    "\ud833\udcd8": "C",
+    "\ud833\udcd9": "D",
+    "\ud833\udcda": "E",
+    "\ud833\udcdb": "F",
+    "\ud833\udcdc": "G",
+    "\ud833\udcdd": "H",
+    "\ud833\udcde": "I",
+    "\ud833\udcdf": "J",
+    "\ud833\udce0": "K",
+    "\ud833\udce1": "L",
+    "\ud833\udce2": "M",
+    "\ud833\udce3": "N",
+    "\ud833\udce4": "O",
+    "\ud833\udce5": "P",
+    "\ud833\udce6": "Q",
+    "\ud833\udce7": "R",
+    "\ud833\udce8": "S",
+    "\ud833\udce9": "T",
+    "\ud833\udcea": "U",
+    "\ud833\udceb": "V",
+    "\ud833\udcec": "W",
+    "\ud833\udced": "X",
+    "\ud833\udcee": "Y",
+    "\ud833\udcef": "Z",
+    "\ud833\udcf0": "0",
+    "\ud833\udcf1": "1",
+    "\ud833\udcf2": "2",
+    "\ud833\udcf3": "3",
+    "\ud833\udcf4": "4",
+    "\ud833\udcf5": "5",
+    "\ud833\udcf6": "6",
+    "\ud833\udcf7": "7",
+    "\ud833\udcf8": "8",
+    "\ud833\udcf9": "9",
+    "\ud838\udc30": "a",
+    "\ud838\udc35": "e",
+    "\ud838\udc3c": "o",
+    "\ud838\udc3e": "p",
+    "\ud838\udc3f": "c",
+    "\ud838\udc41": "y",
+    "\ud838\udc43": "x",
+    "\ud838\udc4c": "i",
+    "\ud838\udc4d": "j",
+    "\ud838\udc51": "a",
+    "\ud838\udc56": "e",
+    "\ud838\udc5c": "o",
+    "\ud838\udc5e": "c",
+    "\ud838\udc5f": "y",
+    "\ud838\udc61": "x",
+    "\ud838\udc68": "i",
+    "\ud838\udc69": "s"
   }
 }

package/pipeline/lib/extract-conventions.sh

@@ -927,11 +927,11 @@ bucket_di_registration() {
   case "$PLATFORM" in
     ios)
       local configurators
-      configurators=$(run_find -type f \( -name '*DependencyConfigurator.swift' -o -name '*Assembly.swift' -o -name '*Module.swift' \) 2>/dev/null | head -20 || true)
+      configurators=$(run_find -type f \( -name '*DependencyConfigurator.swift' -o -name '*DependencyRegistrar.swift' -o -name '*Assembly.swift' -o -name '*Module.swift' \) 2>/dev/null | head -20 || true)
       local resolver_count factory_count manual_count swinject_count
       manual_count=0; resolver_count=0; factory_count=0; swinject_count=0
       if [ -n "$configurators" ]; then
-        manual_count=$(printf '%s\n' "$configurators" | count_matches 'DependencyConfigurator')
+        manual_count=$(printf '%s\n' "$configurators" | count_matches -E 'Dependency(Configurator|Registrar)')
       fi
       files=$(run_find -type f -name '*.swift' 2>/dev/null || true)
       if [ -n "$files" ]; then
@@ -943,7 +943,7 @@ bucket_di_registration() {
 
       sample=$(printf '%s\n' "$configurators" | head -3 | sed "s|^$REPO_PATH/||")
       if [ "$manual_count" -ge "$resolver_count" ] && [ "$manual_count" -ge "$factory_count" ] && [ "$manual_count" -ge "$swinject_count" ] && [ "$manual_count" -gt 0 ]; then
-        emit_bucket "manual *DependencyConfigurator" "FooDependencyConfigurator.swift" "$(confidence_for "$manual_count")" "$(files_to_json "$sample")" '["Resolver","Factory","Swinject"]'
+        emit_bucket "manual per-module registrar" "FooDependencyRegistrar.swift" "$(confidence_for "$manual_count")" "$(files_to_json "$sample")" '["Resolver","Factory","Swinject"]'
       elif [ "$resolver_count" -ge "$factory_count" ] && [ "$resolver_count" -ge "$swinject_count" ] && [ "$resolver_count" -gt 0 ]; then
         emit_bucket "Resolver" "Resolver.register { FooViewModel() }" "$(confidence_for "$resolver_count")" "[]" '["manual-configurator","Factory","Swinject"]'
       elif [ "$factory_count" -ge "$swinject_count" ] && [ "$factory_count" -gt 0 ]; then

package/pipeline/lib/json-file-lock.mjs

@@ -19,7 +19,9 @@
 import {
   chmodSync,
   linkSync,
+  lstatSync,
   readFileSync,
+  realpathSync,
   renameSync,
   rmSync,
   statSync,
@@ -125,17 +127,31 @@ export function withFileLockSync(
 /**
  * Replace `path` with `data` as JSON, atomically, at `mode`.
  *
+ * `followSymlink` is for a file the user owns and may keep in a dotfiles repo
+ * (the preferences file): when `path` is a symlink, the rename lands on its
+ * target, so the link and the dotfiles copy stay in step. Without it a
+ * symlink at `path` is replaced by a regular file, which is the safe default
+ * for a path an unattended run could plant a link at.
+ *
  * @param {string} path
  * @param {unknown} data
- * @param {{mode?: number}} [opts]
+ * @param {{mode?: number, followSymlink?: boolean}} [opts]
  */
-export function writeJsonAtomicSync(path, data, { mode = 0o600 } = {}) {
-  const tmp = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+export function writeJsonAtomicSync(path, data, { mode = 0o600, followSymlink = false } = {}) {
+  let target = path;
+  if (followSymlink) {
+    try {
+      if (lstatSync(path).isSymbolicLink()) target = realpathSync(path);
+    } catch {
+      // Missing file: write the path as given.
+    }
+  }
+  const tmp = join(dirname(target), `.${basename(target)}.${process.pid}.tmp`);
   rmSync(tmp, { force: true });
   try {
     writeFileSync(tmp, `${JSON.stringify(data, null, 2)}\n`, { mode, flag: "wx" });
     chmodSync(tmp, mode);
-    renameSync(tmp, path);
+    renameSync(tmp, target);
   } catch (err) {
     rmSync(tmp, { force: true });
     throw err;
@@ -149,16 +165,20 @@ export function writeJsonAtomicSync(path, data, { mode = 0o600 } = {}) {
  *
  * @param {string} path
  * @param {(current: any) => any} mutate
- * @param {{fallback?: any, mode?: number, timeoutMs?: number, staleMs?: number}} [opts]
+ * @param {{fallback?: any, mode?: number, followSymlink?: boolean, timeoutMs?: number, staleMs?: number}} [opts]
  * @returns {any} the document written, or undefined when nothing was
  */
-export function updateJsonFileSync(path, mutate, { fallback = null, mode = 0o600, ...lock } = {}) {
+export function updateJsonFileSync(
+  path,
+  mutate,
+  { fallback = null, mode = 0o600, followSymlink = false, ...lock } = {},
+) {
   return withFileLockSync(
     path,
     () => {
       const next = mutate(readRegularJson(path, fallback));
       if (next === undefined) return undefined;
-      writeJsonAtomicSync(path, next, { mode });
+      writeJsonAtomicSync(path, next, { mode, followSymlink });
       return next;
     },
     lock,

package/pipeline/lib/normalize-text.mjs

@@ -2,13 +2,20 @@
 /**
  * normalize-text.mjs  -  fold look-alike text to the form a guard matches on.
  *
- * NFKC, then the invisible characters in confusables.json removed and its
- * look-alike letters and punctuation mapped to ASCII. A guard matches on the
- * raw text and on this folded copy, so a trailer or a token written with a
- * zero-width space or a Cyrillic letter is still recognised. The folded copy is
- * only ever matched against; nothing written or shown uses it.
+ * NFKC, then the Default_Ignorable_Code_Point ranges in confusables.json
+ * removed and its look-alike letters and punctuation mapped to ASCII. A guard
+ * matches on the raw text and on this folded copy, so a trailer or a token
+ * written with a zero-width space or a Cyrillic letter is still recognised. The
+ * folded copy is only ever matched against; nothing written or shown uses it.
  *
- * As a CLI it reads stdin and writes the folded text to stdout.
+ * The table is loaded fail-soft: when confusables.json cannot be read the fold
+ * is NFKC alone, `TABLE_LOADED` is false and one notice goes to stderr. The log
+ * redactor keeps working on that reduced fold; the outbound gate checks
+ * `TABLE_LOADED` and refuses to scan.
+ *
+ * As a CLI it reads stdin and writes the folded text to stdout. With `--nul`
+ * it reads NUL-separated records and writes each folded record followed by a
+ * NUL, so a caller folds many texts in one process.
  *
  * @module pipeline/lib/normalize-text
  */
@@ -17,32 +24,94 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { invokedDirectly } from "./invoked-directly.mjs";
 
-const TABLE = JSON.parse(readFileSync(join(import.meta.dirname, "confusables.json"), "utf8"));
-const STRIP = new Set(TABLE.strip);
-const MAP = new Map(Object.entries(TABLE.map));
+function loadTable() {
+  try {
+    const table = JSON.parse(readFileSync(join(import.meta.dirname, "confusables.json"), "utf8"));
+    return { table, loaded: true };
+  } catch (err) {
+    process.stderr.write(
+      `normalize-text: confusables.json unreadable (${err.code || err.name}) - folding with NFKC only\n`,
+    );
+    return { table: {}, loaded: false };
+  }
+}
+
+const { table: TABLE, loaded } = loadTable();
+
+/** False when confusables.json could not be read and the fold is NFKC only. */
+export const TABLE_LOADED = loaded;
+
+function stripSet(table) {
+  const set = new Set();
+  for (const range of table.stripRanges || []) {
+    const [first, last = first] = String(range).split("-");
+    const lo = parseInt(first, 16);
+    const hi = parseInt(last, 16);
+    if (Number.isNaN(lo) || Number.isNaN(hi)) continue;
+    for (let cp = lo; cp <= hi; cp++) set.add(cp);
+  }
+  return set;
+}
+
+const STRIP = stripSet(TABLE);
+const MAP = new Map(Object.entries(TABLE.map || {}));
 
 /** @param {string} text */
 export function normalizeForMatch(text) {
   if (typeof text !== "string" || !text) return text;
   let out = "";
   for (const ch of text.normalize("NFKC")) {
-    if (STRIP.has(ch)) continue;
+    if (STRIP.has(ch.codePointAt(0))) continue;
     out += MAP.get(ch) ?? ch;
   }
   return out;
 }
 
-/** The text with its invisible characters removed and nothing else changed. */
-export function stripInvisible(text) {
-  if (typeof text !== "string" || !text) return text;
-  let out = "";
-  for (const ch of text) if (!STRIP.has(ch)) out += ch;
-  return out;
+/**
+ * The fold of `text` one code point at a time, with the span of the original
+ * each folded UTF-16 unit came from: folded unit `j` came from
+ * `text.slice(start[j], end[j])`. A match on `folded` from `a` to `b` covers
+ * `text.slice(start[a], end[b - 1])`. Folding per code point rather than over
+ * the whole string differs from normalizeForMatch only where NFKC would
+ * compose a base letter with a following combining mark, which no credential
+ * shape contains.
+ *
+ * @param {string} text
+ * @returns {{ folded: string, start: number[], end: number[] }}
+ */
+export function foldWithIndex(text) {
+  const start = [];
+  const end = [];
+  let folded = "";
+  let i = 0;
+  for (const ch of text) {
+    const next = i + ch.length;
+    for (const part of ch.normalize("NFKC")) {
+      if (STRIP.has(part.codePointAt(0))) continue;
+      const mapped = MAP.get(part) ?? part;
+      for (let k = 0; k < mapped.length; k++) {
+        start.push(i);
+        end.push(next);
+      }
+      folded += mapped;
+    }
+    i = next;
+  }
+  return { folded, start, end };
 }
 
 if (invokedDirectly(import.meta.url)) {
+  const nul = process.argv.includes("--nul");
   let input = "";
   process.stdin.setEncoding("utf8");
   process.stdin.on("data", (d) => (input += d));
-  process.stdin.on("end", () => process.stdout.write(normalizeForMatch(input)));
+  process.stdin.on("end", () => {
+    if (!nul) {
+      process.stdout.write(normalizeForMatch(input));
+      return;
+    }
+    const records = input.split("\0");
+    if (records.at(-1) === "") records.pop();
+    process.stdout.write(records.map((r) => `${normalizeForMatch(r)}\0`).join(""));
+  });
 }

package/pipeline/lib/outbound-gate.mjs

@@ -42,14 +42,15 @@
  *   cat body.md | outbound-gate.mjs --warn          # report, never block
  *
  * Exit codes:
- *   0  -  nothing found
+ *   0  -  nothing found, or an empty body
  *   7  -  at least one finding; the caller must not publish
- *   2  -  usage error (no input)
+ *   2  -  usage error (--file without a path)
+ *         or a stdin that cannot be read at all
  */
 
 import { readFileSync } from "node:fs";
 import { invokedDirectly } from "./invoked-directly.mjs";
-import { normalizeForMatch } from "./normalize-text.mjs";
+import { TABLE_LOADED, normalizeForMatch } from "./normalize-text.mjs";
 
 /**
  * Each rule is a SHAPE, not a dictionary. A list of known token prefixes goes
@@ -148,17 +149,25 @@ export const SURFACES = [
   },
 ];
 
+// Printable ASCII and tab fold to themselves; any other line is folded.
+const NEEDS_FOLD = /[^\t -~]/;
+
 /**
  * @param {string} text
  * @returns {{rule: string, certain: boolean, line: number}[]}
  */
 export function scan(text) {
+  // Without the fold table a disguised credential would pass as clean text,
+  // so the gate refuses to scan rather than report nothing.
+  if (!TABLE_LOADED) {
+    throw new Error("outbound-gate: confusables.json unreadable - refusing to scan");
+  }
   const findings = [];
   const lines = String(text).split("\n");
   for (let i = 0; i < lines.length; i++) {
     // A credential written with an invisible character or a look-alike letter
     // still matches: the certain rules also run on the folded line.
-    const folded = normalizeForMatch(lines[i]);
+    const folded = NEEDS_FOLD.test(lines[i]) ? normalizeForMatch(lines[i]) : lines[i];
     for (const rule of RULES) {
       // `lastIndex` survives between calls on a /g regex and would make every
       // second line skip its start. Reset per line.

package/pipeline/lib/redact.mjs

@@ -7,6 +7,13 @@
  * `[redacted:<rule>]`; the text around it is kept, because a log line is read
  * to debug a failure and the message is what makes it useful.
  *
+ * The rules run on the folded copy of the text (normalize-text.mjs), so a token
+ * carrying an invisible character or a look-alike letter is found, and the
+ * span of the ORIGINAL text it came from is the one replaced. Everything
+ * outside a match is written back as it was: a Persian zero-width non-joiner,
+ * a direction mark, an emoji joined by U+200D and a soft hyphen all survive,
+ * and a text with no match is returned unchanged.
+ *
  * As a CLI it reads stdin and writes the redacted text to stdout. It never
  * fails its caller: on an internal error it writes the input unchanged.
  *
@@ -15,27 +22,93 @@
 
 import { RULES } from "./outbound-gate.mjs";
 import { invokedDirectly } from "./invoked-directly.mjs";
-import { stripInvisible } from "./normalize-text.mjs";
+import { foldWithIndex, normalizeForMatch } from "./normalize-text.mjs";
 
 const CERTAIN = RULES.filter((r) => r.certain);
 
+const globalCopy = (re) =>
+  new RegExp(re.source, re.flags.includes("g") ? re.flags : `${re.flags}g`);
+const marker = (name) =>
+  name === "url-with-credentials" ? `[redacted:${name}]@` : `[redacted:${name}]`;
+
+// Where two rules match overlapping text, the one with the longer literal
+// prefix names the span: `sk-ant-...` is an Anthropic key even though the
+// shorter `sk-` OpenAI rule matches it too. Equal prefixes keep rule order.
+const literalPrefix = (re) => (re.source.replace(/^\\b/, "").match(/^[A-Za-z0-9_-]*/) || [""])[0];
+const RANK = new Map(
+  CERTAIN.map((r, i) => [r.name, { specificity: literalPrefix(r.re).length, order: i }]),
+);
+const moreSpecific = (a, b) => {
+  const x = RANK.get(a);
+  const y = RANK.get(b);
+  return x.specificity > y.specificity || (x.specificity === y.specificity && x.order < y.order);
+};
+
+/**
+ * Spans of `text` a certain rule matches, as [from, to, rule], merged and in
+ * order. The rules run on the raw text and on the folded copy: a letter that
+ * folds to a word character (the Turkish dotless i, a ligature, a
+ * mathematical letter) right before a token removes the word boundary the
+ * rule needs in the folded copy only, and a look-alike inside a token hides it
+ * from the raw text only. Raw spans are already in original indices; folded
+ * ones are mapped back through the fold's index.
+ */
+function findSpans(text) {
+  const spans = [];
+  for (const rule of CERTAIN) {
+    for (const m of text.matchAll(globalCopy(rule.re))) {
+      if (m[0]) spans.push([m.index, m.index + m[0].length, rule.name]);
+    }
+  }
+  const { folded, start, end } = foldWithIndex(text);
+  if (folded !== text) {
+    for (const rule of CERTAIN) {
+      for (const m of folded.matchAll(globalCopy(rule.re))) {
+        if (!m[0]) continue;
+        spans.push([start[m.index], end[m.index + m[0].length - 1], rule.name]);
+      }
+    }
+  }
+  spans.sort((x, y) => x[0] - y[0] || y[1] - x[1]);
+  const merged = [];
+  for (const s of spans) {
+    const last = merged.at(-1);
+    if (last && s[0] < last[1]) {
+      if (s[1] > last[1]) last[1] = s[1];
+      if (moreSpecific(s[2], last[2])) last[2] = s[2];
+    } else {
+      merged.push([...s]);
+    }
+  }
+  return merged;
+}
+
+function stillMatches(text) {
+  const folded = normalizeForMatch(text);
+  return CERTAIN.find((r) => globalCopy(r.re).test(text) || globalCopy(r.re).test(folded));
+}
+
 /** @param {string} text */
 export function redact(text) {
   if (typeof text !== "string" || !text) return text;
-  // Invisible characters are removed first, joiners included, so a token split
-  // by one cannot slip past the rules. The logged line loses them too: an emoji
-  // sequence joined by U+200D prints as its separate parts.
-  let out = stripInvisible(text);
-  for (const rule of CERTAIN) {
-    const re = new RegExp(
-      rule.re.source,
-      rule.re.flags.includes("g") ? rule.re.flags : `${rule.re.flags}g`,
-    );
-    out = out.replace(re, () =>
-      rule.name === "url-with-credentials" ? `[redacted:${rule.name}]@` : `[redacted:${rule.name}]`,
-    );
+  const spans = findSpans(text);
+  let out = text;
+  for (let k = spans.length - 1; k >= 0; k--) {
+    const [from, to, name] = spans[k];
+    out = out.slice(0, from) + marker(name) + out.slice(to);
   }
-  return out;
+  // The per-code-point fold that locates spans can differ from the whole-text
+  // fold the gate uses where NFKC composes across characters. A line the gate
+  // would still flag after both the raw and the folded spans are replaced is
+  // replaced whole rather than written with a credential.
+  if (!stillMatches(out)) return out;
+  return out
+    .split("\n")
+    .map((line) => {
+      const rule = stillMatches(line);
+      return rule ? marker(rule.name) : line;
+    })
+    .join("\n");
 }
 
 if (invokedDirectly(import.meta.url)) {

package/pipeline/multi-agent-refs/analysis/evidence.md

@@ -107,7 +107,7 @@ the bucket patterns use (`docs/adr/0010-own-code-graph.md`).
 | domainEntities | `Domain/Entities/*.swift` | `domain/entities/*.kt` / `entities/*.py` |
 | routes | Public `enum *Route` matching `DomainRoute` | `*Route` sealed / NavRoute / `routes.*` modules |
 | coordinators | `*Coordinator.swift` + `CoordinatorProtocol`/`DomainRouter` | Navigator / NavController helpers |
-| diConfigurators | `*DependencyConfigurator.swift`, `Module.kt` (Hilt) | DI container registrations |
+| diConfigurators | `*DependencyRegistrar.swift`, `*Assembly.swift`, `Module.kt` (Hilt) | DI container registrations |
 | uiComponents | `Common/UIComponents/.../Components/**/*.swift` triplet (Configuration + View + +Modifiers) | Compose @Composable functions / React components |
 | tokens | `*Token` enums under `UIAssetTokens/Generated/` | `Theme.kt` / `tokens.ts` / `tailwind.config.*` |
 | localizationKeys | `LocalizationStringKeys.swift` public enum + cases | `strings.xml` keys / `i18n/*.json` keys |

package/pipeline/multi-agent-refs/analysis/synthesis.md

@@ -49,7 +49,7 @@ Convention preview - Pass B will render with:
 | Test naming | @Test func scenario_expected() ^[C4 medium: 4 examples] | fun scenario_expectedBehavior() ^[C4 high] |
 | Identifier | userProfile.continueButton ^[C5 high] | userProfileContinueButton ^[C5 medium] |
 | Localization key | UserProfile.ContinueButton ^[C6 high] | user_profile_continue_button ^[C6 high] |
-| DI | UserProfileDependencyConfigurator ^[C7 high] | UserProfileModule (Hilt) ^[C7 fallback: defaults] |
+| DI | UserProfileDependencyRegistrar ^[C7 high] | UserProfileModule (Hilt) ^[C7 fallback: defaults] |
 
 Confidence summary:
   iOS:     5/5 high, 0 medium, 0 low, 0 fallback

package/pipeline/multi-agent-refs/component-dispatch.md

@@ -47,7 +47,7 @@ run produced entities and a mapper but left the screen half-wired.
 
 | `state.componentScope` | Meaning | iOS skill | Android skill |
 |---|---|---|---|
-| `screen` (default when the frame is a full screen, or the task names a screen) | Full clean-architecture vertical: Entity → Repository → Mapper → UseCase → LocalizedText → AnalyticsTracking → CoordinatorEvent → ViewModel → Scene → Preview, then verify | `ai-ios-toolkit:create-screen` | `ai-android-toolkit:create-screen` |
+| `screen` (default when the frame is a full screen, or the task names a screen) | Full clean-architecture vertical: Entity → Repository → Mapper → UseCase → Copy → AnalyticsTracking → CoordinatorEvent → ViewModel → Scene → Preview, then verify | `ai-ios-toolkit:create-screen` | `ai-android-toolkit:create-screen` |
 | `component` | One reusable UI component (Configuration / View / +Modifiers / Code Connect) | `ai-ios-toolkit:create-component` (fallback `create-ui-component`) | `ai-android-toolkit:create-component` (fallback `create-ui-component`) |
 | `evolve` | Change an existing component | `evolve-component` (fallback `evolve-ui-component`) | same |
 

package/pipeline/multi-agent-refs/conventions-defaults.md

@@ -160,7 +160,7 @@ Detection: scan up to 10 SwiftUI view files in the candidate set; majority pick
 
 | Platform | Default | Example | Rationale |
 |---|---|---|---|
-| iOS | Manual configurator | `<Domain>DependencyConfigurator.register<Feature>()` | Avoids framework lock-in; testable |
+| iOS | Manual configurator | `<Domain>DependencyRegistrar.register<Feature>()` | Avoids framework lock-in; testable |
 | Android | Hilt module | `@Module @InstallIn(SingletonComponent::class) class <Feature>Module` | Standard Android DI |
 | Backend FastAPI | `Depends(get_<feature>_service)` | `service: OrderSummaryService = Depends(get_order_summary_service)` | Native FastAPI pattern |
 | Web | hook factory | `useOrderSummaryApi()` returns a memoized client | No framework DI needed |

package/pipeline/multi-agent-refs/features/unattended-security.md

@@ -287,8 +287,8 @@ Before every launch - the dev run, a research pass, a resume - the runner:
   settings, read the way `install/claude.mjs` writes it: a matcher is a regex
   over the tool name (the legacy `Bash(git push:*)` covers nothing, and the web
   entry has to cover `agent_run_steps` and both `open_url` tools), the hook
-  command is exactly the installer's `bash $HOME/.claude/scripts/agent-guard.sh`
-  (or the same path with `$HOME` expanded) and that script exists. The
+  command is exactly the installer's `bash "$HOME/.claude/scripts/agent-guard.sh"`
+  (quoted or not, or the same path with `$HOME` expanded) and that script exists. The
   checkout's `.claude/` settings never count toward the registration - the repo
   under work is not where the guard may come from - but `disableAllHooks` in
   any of these files, the checkout's included, turns every hook off. It also