@agentsfleet/orly 0.14.3 → 0.14.4

package/README.md

@@ -78,7 +78,7 @@ TypeSafe's Jev model supplies runtime advice through explicit `orly judge` reque
 
 See [releases](https://github.com/agentsfleet/orly/releases) for published versions.
 The install commands below fetch the published package.
-The release workflow publishes 0.14.3 after its version change merges to `main`.
+The release workflow publishes 0.14.4 after its version change merges to `main`.
 
 ---
 

package/audits/msid-ui.sh

@@ -99,7 +99,23 @@ case "$MODE" in
     EXPLICIT=("$@"); POST_REF=""; LABEL="explicit files" ;;
 esac
 
-# Single awk pass; reads stdin (the unified diff).
+# --staged/--diff: one git diff piped into one awk — the scan itself costs
+# two processes however large the staged set, plus at most one `git show`
+# per file holding a candidate hit line (zero for a clean diff). Explicit
+# mode keeps a per-file scan so the reported path is the caller's own argv
+# string (git's --no-index headers strip the leading slash of absolute
+# paths, which would misreport the hit and misread the post-image).
+# This gate runs inside a 30-minute pre-commit budget that the previous
+# per-file fork loop blew through at 1,628 staged files.
+#
+# The awk learns the current file from the diff's own `+++ b/<path>` header
+# instead of a shell loop variable. That parse is made safe on purpose:
+#   * `--src-prefix=a/ --dst-prefix=b/` pins the prefixes, because user config
+#     (diff.noprefix, diff.mnemonicPrefix) may rename them.
+#   * git C-quotes paths containing control characters, `"` or `\` (and with
+#     the default core.quotePath, non-ASCII bytes — hence `-c
+#     core.quotePath=false` on the git calls), so the header is unquoted in
+#     awk. git terminates the header path with one TAB, quoted or not.
 #
 # Carve-out recognition reads the preceding line from the SOURCE, not from the
 # diff. Every carve-out here — the two override markers and the design-system
@@ -112,29 +128,21 @@ esac
 # override comment stopped covering the line it sits above the moment that line
 # was next touched.
 #
-# The hunk header carries the post-image line number, so `line_above` can fetch
-# the neighbouring line out of the post-image the mode named. Same shape as
-# audits/design-tokens.sh, which has always read its override out of the file.
+# The hunk header carries the post-image line number, so `line_above` answers
+# from the post-image the mode named. The post-image is slurped once per file —
+# on the file's first *candidate* hit line, since only candidates (a line
+# matching the MS-ID or UI regexes in a scoped file) ever read the neighbour —
+# and dropped when the next file's `diff --git` section opens. One `git show`
+# per candidate file, zero for a clean diff, and memory bounded by one file.
 scan_diff() {
-ORLY_AUDIT_PATH="$1" awk -v post_ref="$POST_REF" '
+awk -v post_ref="$POST_REF" '
   # BWK awk (macOS) has no gensub and no --posix quoting help; APOSTROPHE is
   # built rather than written, because this program is inside single quotes.
-  BEGIN { APOSTROPHE = sprintf("%c", 39); f = ENVIRON["ORLY_AUDIT_PATH"] }
-
-  # The source line above line `n` of `path`, from the post-image, or "" when
-  # there is none. Cached: a hunk may ask about the same neighbour repeatedly,
-  # and each miss costs a fork.
-  function line_above(path, n,    key, cmd, out) {
-    if (n <= 1) return ""
-    key = path SUBSEP n
-    if (key in above) return above[key]
-    above[key] = ""
-    if (post_ref == "") cmd = "sed -n " (n - 1) "p " shell_quote(path)
-    else cmd = "git show " shell_quote(post_ref path) " 2>/dev/null | sed -n " (n - 1) "p"
-    if ((cmd | getline out) > 0) above[key] = out
-    close(cmd)
-    return above[key]
-  }
+  # Explicit mode names its file through the environment (see the driver) and
+  # the header parse below then never overrides it; the diff modes pass an
+  # empty value and every `+++` header re-attributes f.
+  BEGIN { APOSTROPHE = sprintf("%c", 39); in_hunk = 0; loaded = 0; imgn = 0
+          f = ENVIRON["ORLY_AUDIT_PATH"]; fixed_f = (f != "") }
 
   function shell_quote(s,    i,c,out) {
     out = APOSTROPHE
@@ -145,23 +153,113 @@ ORLY_AUDIT_PATH="$1" awk -v post_ref="$POST_REF" '
     }
     return out APOSTROPHE
   }
+
+  # The post-image path a `+++ ` header names: C-quote resolved (git wraps
+  # the whole "b/<path>" in quotes), the pinned b/ prefix removed. /dev/null
+  # maps to the empty path, which matches no scope below.
+  function dst_path(header,    rest,out,i,c,nxt,q,oct,v,j) {
+    rest = substr(header, 5)
+    if (rest == "/dev/null") return ""
+    if (substr(rest, 1, 1) == "\"") {
+      q = 0
+      for (i = length(rest); i >= 2; i--) if (substr(rest, i, 1) == "\"") { q = i; break }
+      rest = substr(rest, 2, q - 2)
+      out = ""
+      i = 1
+      while (i <= length(rest)) {
+        c = substr(rest, i, 1)
+        if (c == "\\") {
+          nxt = substr(rest, i + 1, 1)
+          if (nxt ~ /[0-7]/) {
+            # \ooo octal escape, one to three digits (only control bytes reach
+            # here: core.quotePath=false passes non-ASCII through raw).
+            oct = nxt
+            while (length(oct) < 3 && substr(rest, i + 1 + length(oct), 1) ~ /[0-7]/)
+              oct = oct substr(rest, i + 1 + length(oct), 1)
+            v = 0
+            for (j = 1; j <= length(oct); j++) v = v * 8 + substr(oct, j, 1)
+            out = out sprintf("%c", v)
+            i += 1 + length(oct)
+          } else {
+            if (nxt == "a") out = out sprintf("%c", 7)
+            else if (nxt == "b") out = out sprintf("%c", 8)
+            else if (nxt == "f") out = out "\f"
+            else if (nxt == "n") out = out "\n"
+            else if (nxt == "r") out = out "\r"
+            else if (nxt == "t") out = out "\t"
+            else if (nxt == "v") out = out "\v"
+            else out = out nxt
+            i += 2
+          }
+        } else { out = out c; i++ }
+      }
+      rest = out
+    } else {
+      # Unquoted: drop the single trailing TAB git appends to the header
+      # path. A literal tab in a filename forces C-quoting, so a trailing
+      # tab here is never name content; a trailing SPACE is, and is kept.
+      sub(/\t$/, "", rest)
+    }
+    sub(/^b\//, "", rest)
+    return rest
+  }
+
+  function load_postimage(    cmd,l) {
+    imgn = 0
+    if (post_ref == "") {
+      while ((getline l < f) > 0) { imgn++; img[imgn] = l }
+      close(f)
+    } else {
+      cmd = "git show " shell_quote(post_ref f) " 2>/dev/null"
+      while ((cmd | getline l) > 0) { imgn++; img[imgn] = l }
+      close(cmd)
+    }
+    loaded = 1
+  }
+
+  # The source line above post-image line `n` of the current file, or "" when
+  # there is none. Reads the slurped post-image; the slurp happens at most
+  # once per file section.
+  function line_above(n) {
+    if (n <= 1) return ""
+    if (!loaded) load_postimage()
+    if (n - 1 > imgn) return ""
+    return img[n - 1]
+  }
+
+  # A new file section: reset hunk state and drop the previous post-image —
+  # lookups only ever concern the file of the open section.
+  /^diff --git / {
+    in_hunk = 0
+    if (loaded) { for (i = 1; i <= imgn; i++) delete img[i]; imgn = 0; loaded = 0 }
+    next
+  }
+  !in_hunk && /^\+\+\+ / { if (!fixed_f) f = dst_path($0); next }
   /^\+\+\+/ { next }
   # `@@ -a,b +c,d @@` — $3 is the post-image start line for this hunk.
-  /^@@/ { start=$3; sub(/^\+/,"",start); split(start,parts,","); nl=parts[1]+0; next }
+  /^@@/ { in_hunk = 1; start=$3; sub(/^\+/,"",start); split(start,parts,","); nl=parts[1]+0; next }
   /^[^+]/ { next }
   /^\+/ {
     line=$0
     sub(/^\+/,"",line)
-    prev = line_above(f, nl)
+    # The line above is fetched only for candidate hits: every reader of
+    # `prev` sits behind one of these two guards, so a line that matches
+    # neither regex never pays for the post-image.
+    msid_cand = f ~ /\.(zig|sql|ts|tsx|js|jsx|py|rs|go|sh|toml|yaml|json)$/ &&
+                f !~ /^(docs|node_modules|vendor|third_party)\// &&
+                match(line, /M[0-9]+_[0-9]+|§[0-9]+(\.[0-9]+)+|(^|[^A-Za-z0-9_])T[0-9]+([^A-Za-z0-9_]|$)|(^|[^A-Za-z0-9_])dim [0-9]+\.[0-9]+([^A-Za-z0-9_]|$)/)
+    ui_cand = f ~ /^ui\/packages\/app\/.*\.(tsx|jsx)$/ &&
+              line ~ /<(section|button|input|dialog|article|nav|header|form)[ \t>\/]/
+    if (msid_cand || ui_cand) {
+      prev = line_above(nl)
+      ms_id_override = (prev ~ /MILESTONE ID ALLOWED per user override/)
+      ui_override = (prev ~ /UI GATE: SKIPPED per user override/)
+    } else {
+      prev = ""; ms_id_override = 0; ui_override = 0
+    }
     nl++
-    ms_id_override = (prev ~ /MILESTONE ID ALLOWED per user override/)
-    ui_override = (prev ~ /UI GATE: SKIPPED per user override/)
-    if (!ms_id_override &&
-        f ~ /\.(zig|sql|ts|tsx|js|jsx|py|rs|go|sh|toml|yaml|json)$/ &&
-        f !~ /^(docs|node_modules|vendor|third_party)\//) {
-      if (match(line, /M[0-9]+_[0-9]+|§[0-9]+(\.[0-9]+)+|(^|[^A-Za-z0-9_])T[0-9]+([^A-Za-z0-9_]|$)|(^|[^A-Za-z0-9_])dim [0-9]+\.[0-9]+([^A-Za-z0-9_]|$)/)) {
-        print "MS-ID  " f ": " line
-      }
+    if (msid_cand && !ms_id_override) {
+      print "MS-ID  " f ": " line
     }
     # react-hook-form caveat: its prescribed shape is a raw
     # <form onSubmit={form.handleSubmit(...)}> inside the design-system <Form>
@@ -179,9 +277,7 @@ ORLY_AUDIT_PATH="$1" awk -v post_ref="$POST_REF" '
     # is above it in the file whether or not this diff touched it. A
     # bare/unwrapped <section> still trips.
     ds_section = (line ~ /<section[ \t]/ && prev ~ /<Section asChild>/)
-    if (!ui_override && !rhf_form && !ds_section &&
-        f ~ /^ui\/packages\/app\/.*\.(tsx|jsx)$/ &&
-        line ~ /<(section|button|input|dialog|article|nav|header|form)[ \t>\/]/) {
+    if (ui_cand && !ui_override && !rhf_form && !ds_section) {
       print "UI     " f ": " line
     }
   }
@@ -193,12 +289,14 @@ hits=$(
     for path in "${EXPLICIT[@]}"; do
       [ -f "$path" ] || continue
       # diff returns one for differences; that is expected input here.
-      { git diff --no-index --no-ext-diff -U0 -- /dev/null "$path" || [ "$?" -eq 1 ]; } | scan_diff "$path"
+      { git -c core.quotePath=false diff --no-index --no-ext-diff -U0 --src-prefix=a/ --dst-prefix=b/ -- /dev/null "$path" || [ "$?" -eq 1 ]; } | ORLY_AUDIT_PATH="$path" scan_diff
     done
   else
-    while IFS= read -r -d '' path; do
-      git diff --no-ext-diff -U0 "${DIFF_ARGS[@]}" -- "$path" | scan_diff "$path"
-    done < <(git diff --name-only -z --diff-filter=ACMRT "${DIFF_ARGS[@]}")
+    # --no-renames pins a rename to its delete+add shape: this gate scores
+    # added lines, and its verdicts are defined over renamed files being
+    # re-scanned as whole-file additions. Rename detection would silently
+    # stop scanning their contents.
+    git -c core.quotePath=false diff --no-ext-diff -U0 --no-renames --diff-filter=ACMRT --src-prefix=a/ --dst-prefix=b/ "${DIFF_ARGS[@]}" | ORLY_AUDIT_PATH="" scan_diff
   fi
 )
 

package/docs/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.14.4 — 2026-10-16
+
+The milestone-ID and UI-substitution audit no longer forks per staged file. A pre-commit stage of ~1,600 files that ran over 27 minutes now finishes in about two seconds, with verdicts unchanged.
+
+- **Scan** — one `git diff` and one `awk` cover the whole staged set. Reading the line above an added line now costs at most one `git show` per file with a candidate hit, down from one fork pair per added line.
+- **Compatibility** — verdicts, hit order and exit codes match 0.14.3 byte-for-byte across staged, `--diff` and explicit-file modes, including spaced, quoted and non-ASCII filenames, renames re-scanned as whole-file additions, and absolute explicit paths.
+
 ## 0.14.3 — 2026-10-15
 
 The REST API guide carries agentsfleet's conversation and reviewed-setup exceptions, and the TypeScript rules name how timestamps are labelled.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentsfleet/orly",
-  "version": "0.14.3",
+  "version": "0.14.4",
   "description": "Repository-scoped engineering harness: renders agent rules, materialises the gates that enforce them, and proves the PR boundary \u2014 for any coding agent.",
   "license": "MIT",
   "type": "module",

package/src/scanner_scope.test.ts

@@ -30,6 +30,10 @@ const ERROR_TYPE = "pub struct Error;\n";
 const VALUE_INIT = "pub fn init() Self { return .{}; }\n";
 const ALLOCATING_INIT = "pub fn init(a: std.mem.Allocator) !Self { const owned = try a.alloc(u8, COUNT); return .{ .owned = owned }; }\n";
 const DIFF = "--diff";
+const SPACED = "lib/has space.ts";
+const TRAILING_SPACE = "lib/trail .ts";
+const OVERRIDE = "MILESTONE ID ALLOWED per user override (reason: pin)";
+const MARKED_T = 'const t = "T' + '7";\n';
 const SCANNERS = ["ufs.sh", "logging.sh", "deinit-pairs.sh", "sql-mod.sh", "error-codes.sh", "rust-error.sh", "design-tokens.sh"];
 
 setDefaultTimeout(TEST_TIMEOUT_MS);
@@ -189,6 +193,39 @@ test("diff marker explicit files use working bytes and missing comparisons refus
   expect(missing.text).toContain("comparison revision is missing: missing-revision");
 });
 
+test("diff markers survive spaced and trailing-space filenames", async () => {
+  const project = newRepository();
+  await staged(project, SPACED, MARKED);
+  await staged(project, TRAILING_SPACE, MARKED);
+  const result = scan(project, "audits/msid-ui.sh", [STAGED]);
+  expect(result.code).toBe(1);
+  expect(result.text).toContain(`MS-ID  ${SPACED}: // ${MARKER}`);
+  expect(result.text).toContain(`MS-ID  ${TRAILING_SPACE}: // ${MARKER}`);
+});
+
+test("pure rename re-scans the file as a whole-file addition", async () => {
+  const project = newRepository();
+  await staged(project, "lib/old.ts", MARKED);
+  git(project, COMMIT, "-qm", "test: seed rename");
+  git(project, "mv", "lib/old.ts", "lib/new.ts");
+  const result = scan(project, "audits/msid-ui.sh", [STAGED]);
+  expect(result.code).toBe(1);
+  expect(result.text).toContain(`MS-ID  lib/new.ts: // ${MARKER}`);
+});
+
+test("explicit absolute paths keep the caller path and read its post-image", async () => {
+  const project = newRepository();
+  const absolute = join(temporaryDirectory(), "outside.ts");
+  await Bun.write(absolute, `// ${OVERRIDE}\n${MARKED_T}`);
+  const suppressed = scan(project, "audits/msid-ui.sh", [absolute]);
+  expect(suppressed.code).toBe(0);
+  expect(suppressed.text).toContain("0 hits");
+  await Bun.write(absolute, MARKED_T);
+  const flagged = scan(project, "audits/msid-ui.sh", [absolute]);
+  expect(flagged.code).toBe(1);
+  expect(flagged.text).toContain(`MS-ID  ${absolute}: const t = "T` + `7";`);
+});
+
 test("indexed source links cannot read outside their owned snapshot", async () => {
   const project = newRepository();
   const external = join(temporaryDirectory(), "owner.ts");