fix(#4748): carry a letter-suffixed phase id through the seven shell sites that aborted or truncated it (#4768)
* test(#4748): pin the letter-axis defect at the seven shell sites outside #4660's six
Extends tests/nsegment-phase-grammar.test.cjs one class over: for each of the
seven sites the live shell lines are read off disk by anchor and executed in
bash against a letter-suffixed fixture. The four `$((10#$PHASE_INT))` split
sites must yield PHASE_N without a shell error for `03A` / `12A` / `3A` /
`03A.1.2` and the commit-scope ERE they build must match both `feat(3A-01):`
and `feat(03A-1):`; the review-file lookup must bind init's `padded_phase`
rather than re-pad in shell; the `--from`/`--to`/`--only` and
plan-review-convergence extractions must return `12A` / `23A.1.2` (and
`23.1.2`) whole; the legacy normalizer must pad `3A` to `03A` and must not
mangle an already-padded `08`. Every pre-existing shape (`06`, `08.5`,
`23.1.2`, `36.14`) is a regression control.
tests/init.test.cjs asserts `init execute-phase` emits `padded_phase` for a
directory-backed `03A`, a ROADMAP-only `4B` (→ `04B`), the existing ROADMAP
fallback `1` (→ `01`), and `null` when the phase is not found.
Negative control against the unfixed tree: 41 failures in the grammar file,
exactly the "(fails before the fix)" cases and the three derived from them
(scope ERE, three-flag extraction, the `08` octal trap); 2 in init.test.cjs,
both the new assertions. Every regression control already green.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* fix(#4748): carry a letter-suffixed phase id through the seven shell sites that aborted or truncated it
The canonical phase-number grammar (src/phase-id.cts) is digits, an optional
uppercase letter, then dotted segments — `12A`, `3A`, `23A.1.2` are documented
shapes that `init`, `phase-id.cts` and `phase remove` renumbering already
round-trip. Seven shell sites in shipped workflows and references still
assumed digits-and-dots. Four classes, one fix each:
Class 1 — `PHASE_INT=${PHASE_NUMBER%%.*}; $((10#$PHASE_INT))` (execute-phase.md
×2, completion-reconciliation.md, tdd.md). The post-#4619 split stops at the
first DOT, so on `03A` the "integer" is `03A` and bash aborts with `value too
great for base`. Split at the first NON-DIGIT instead (`%%[!0-9]*`): the
integer half is a pure digit run, and the letter rides along in the rest the
way the dotted fraction already did — `03A.1.2` → PHASE_N `3A\.1\.2`, so the
#4003 zero-pad-tolerant scope ERE matches both `feat(3A-01):` and
`feat(03A-1):`. Byte-identical output for every id that worked before.
Class 2 — `PADDED=$(printf "%02d" "${PHASE_NUMBER}")` before the REVIEW.md
lookup (execute-phase.md). `printf` cannot pad a letter id (prints `03`,
exits 1) — and cannot even re-pad an already-padded `08`, which bash reads as
an invalid octal and prints as `00`, so the lookup resolved phases 08 and 09
to `00-REVIEW.md` today. The disk path hands the workflow the directory's
padded number but the ROADMAP fallback hands it the heading's bare one, which
is why the re-pad existed. `cmdInitExecutePhase` now emits `padded_phase`
through `normalizePhaseName`, exactly as the plan-phase and code-review inits
do, and the workflow binds `{padded_phase}` instead of re-deriving.
Class 3 — `grep -oE '[0-9]+\.?[0-9]*'` (autonomous.md `--from`/`--to`/`--only`,
plan-review-convergence.md). Stops at the letter, so `--from 12A` ran from
phase 12 with no error. Now the canonical ERE `[0-9]+[A-Z]?(\.[0-9]+)*`, which
also closes the single-segment dot-axis gap the same shape carried (`23.1.2`
→ `23.1`, #4568's class in a spelling neither lint saw).
Class 4 — the legacy manual normalizer (phase-argument-parsing.md, reached
from mvp-phase.md). Its two branches (`^[0-9]+$`, `^[0-9]+\.[0-9]+$`) left
`12A` unpadded and never padded `3A` to the `03A` a directory carries; its
integer branch also hit the same `printf` octal trap on `08`. One branch for
the whole canonical token now, padding the digit run via `$((10#…))`.
Whether this legacy surface should instead be retired in favour of `init`'s
normalization is the maintainer call the issue names; extending it keeps the
documented contract true either way.
Driven end to end: `init execute-phase 3A` on a fixture with a
`03A-letter-variant/` directory emits `phase_number: "03A"` and now
`padded_phase: "03A"`; on a ROADMAP-only `### Phase 4B:` it emits `"4B"` /
`"04B"`. The issue's own evidence line claimed `padded_phase` was already in
the execute-phase init output — it was not; that key is emitted by the
code-review / plan-phase inits, which is where the claim was read from.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4634): extend lint-phase-id-drift with three ratchets for letter-hostile phase-id consumers
The rules that landed with #4619, #4568 and #4660 police grammar MIRRORS —
regexes that describe a phase id. The #4748 sites are CONSUMERS of one, and
every existing rule reported clean on them: the shell-arithmetic rule's
`_INT` escape trusts a NAME the dot-only split did not earn on `03A`; the
`[0-9]+\.?[0-9]*` shape is neither the bounded form the single-segment rule
bans nor the unbounded form the letterless rule inspects; and nothing looked
at `printf "%02d"` at all. Three narrow additions, one per shape:
- findDotOnlyIntegerSplitDrift — `X_INT=${<phase-var>%%.*}`; the safe split
is `%%[!0-9]*`. Keys on the SOURCE variable being phase-carrying.
- findLooseDottedPhaseRegexDrift — `[0-9]+\.?[0-9]*` / `\d+\.?\d*` on a
phase-carrying line; the canonical form is `[0-9]+[A-Z]?(\.[0-9]+)*`.
Disjoint from the two sibling regex rules by construction.
- findShellPhasePrintfPadDrift — `printf "%0Nd" …` whose arguments name a
phase-carrying, non-`_INT` variable; a pad of an `_INT` via `$((10#…))`
and a `{padded_phase}` binding are the sanctioned shapes.
Same `<!-- phase-id-owner: … -->` sanction, same scan roots as their nearest
sibling (shell idioms over workflows + references, the regex shape over
workflows + references + agents), same documented limit of a per-line
textual scan. The post-#4619 comment that described the `_INT` convention
as proven by `%%.*` is corrected to name the digit-run split. Confirmed
against the base commit: each rule fires on exactly its own unfixed sites
(2+1+1, 3+1, 1+1) and zero violations remain on the fixed tree.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* docs(#4748): add Fixed changeset
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4748): refresh the compact-content benchmark baseline and acknowledge emitted growth
The three top-level workflow files below grew by the letter-aware split, the
canonical extraction ERE, the `{padded_phase}` binding, and the comment lines
that name the grammar each site now honours. The committed compact-content
benchmark moved with them; refreshed with `benchmark-compact-content.cjs
--write` (aggregate reduction 15.47% -> 15.45%).
Emitted-Drift-Ack-Growth: execute-phase.md — #4748: first-non-digit PHASE_INT split at the plan-selection and TDD-gate sites, `{padded_phase}` binding at the REVIEW.md lookup, and the comments naming why (482 bytes)
Emitted-Drift-Ack-Growth: autonomous.md — #4748: canonical `[0-9]+[A-Z]?(\.[0-9]+)*` at the --from/--to/--only extractions plus one comment naming the grammar (249 bytes)
Emitted-Drift-Ack-Growth: plan-review-convergence.md — #4748: canonical `[0-9]+[A-Z]?(\.[0-9]+)*` at the phase extraction plus one comment naming the grammar (160 bytes)
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* fix(#4748): name padded_phase in execute-phase.md's init parse list
A `{field}` token inside a workflow bash block is substituted from the init
JSON only for fields the workflow tells the model to parse. `phase_number`
is on that list; `padded_phase` was not, so the `PADDED="{padded_phase}"`
binding at the review lookup would have been a literal — for every phase,
not only letter ones. Found by the pre-file adversarial review (claim 2, the
author's own named suspicion); the test now asserts the parse list carries
the field beside `phase_number`.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4634): key the dot-only split rule on its source and widen the printf rule to any %d form
Two false negatives from the pre-file adversarial review of the three #4748
ratchets: `PHASE_PREFIX=${PHASE_NUMBER%%.*}` escaped the split rule because
the destination did not end in `_INT` (the defect is the split, not the
name it lands in), and `printf '%02d'` / `printf "%2d"` escaped the printf
rule because it required double quotes and the zero flag (`%d` cannot parse
a letter id under any width). Both rules now key on the phase-carrying
SOURCE alone; base-site firing counts are unchanged (2+1+1, 1+1) and the
fixed tree stays at zero. The `[[:digit:]]` spelling and the `/phase/i`
heuristic remain the sibling rules' documented limits.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4748): refresh the compact-content benchmark baseline after the parse-list edit
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* test(#4748): compose init's emitted padded_phase through the live REVIEW.md lookup
The Class 2 site is a `{padded_phase}` template token, which no test can
execute as written. This substitutes the value init emits
(`normalizePhaseName`) into the three live lookup lines and runs them
against a fixture, so the emitted value, the binding, the path construction
and the status extraction are exercised together — `03A-REVIEW.md` and
`08-REVIEW.md` each resolve to their own status. Suggested by the resumed
adversarial review pass (claim C).
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* test(#4748): move the #4619 and #4003 source-parity pins to the letter-safe split
tests/execute-phase-decimal-arithmetic.test.cjs and
tests/safe-resume-gate-anchoring.test.cjs pin the four Class 1 sites'
snippet byte-for-byte, so the first-non-digit split reddened both in the
whole-suite run (scripts/ci-test-scope.cjs does not select either file for
a workflow edit — the scoped run was green). The pinned snippet is now the
shipped one, and the behavioural half of the #4619 file gains the letter
case (`03A` → `3A`, `23A.1.2` → `23A\.1\.2`) beside its decimal cases.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4634): key the dot-only split rule on the _INT destination again, tolerating the quoted spelling
Keying on the source alone (the previous commit's widening, from a review
probe) flags `PARENT_PHASE="${PHASE_NUMBER%%.*}"` in
gap-closure-artifacts.md — a correct derivation that wants everything
before the first dot, letter included. The defect this rule polices is a
dot split INTO the name the shell-arithmetic rule trusts as an integer, so
`_INT` is the discriminator on purpose; the quoted spelling that site uses
is now tolerated so the same shape into an `_INT` cannot hide behind it.
Base-site firing unchanged (2+1+1), zero on the fixed tree, and the
parent-phase line is pinned as a silent case.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* test(#4748): use t.after() for the composition test's fixture cleanup
CONTRIBUTING forbids try/finally inside a test body; the per-test cleanup
form is `t.after(() => cleanup(dir))`. Flagged by the filing driver's
test-ruleset gate before the PR was created.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
* chore(#4748): set changeset fragment pr to 4768
* chore(#4748): refresh the compact-content benchmark baseline after rebasing onto next
Regenerated with `node scripts/benchmark-compact-content.cjs --write` on the
rebased tree (base 0d6bf19bf); `--check` confirms it matches the live recompute.
Only the execute-phase split and the aggregate totals differ from next's copy.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017cjzdZtYjcBAa3Lqh2VrLK
---------
Co-authored-by: Claude Fable 5.1 <noreply@anthropic.com>
Co-authored-by: Tom Boucher <trekkie@nomorestars.com>
This commit is contained in:
0xdhx
@@ -246,11 +246,14 @@ function findBranchSlugFallbackDrift(text) {
|
||||
// 1. Prose mentioning the literal pattern in a full-line `#`-comment
|
||||
// (filtered by the caller, not this regex — see below).
|
||||
// 2. `$((10#$PHASE_INT))` / `$((10#$SPOT_PHASE_INT))` — arithmetic on the
|
||||
// NOW-safe variable the #4619 fix produces via `PHASE_INT=${PHASE_NUMBER%%.*}`;
|
||||
// a `%%.*`-stripped value can never contain a dot, so base-10 arithmetic
|
||||
// on it can never hit the #4619 syntax-error class. Any name ending in
|
||||
// `_INT` (case-insensitive) is that established "already reduced to a
|
||||
// safe integer" convention.
|
||||
// NOW-safe variable the #4619 fix produces via a leading-digit-run split
|
||||
// (`PHASE_INT=${PHASE_NUMBER%%[!0-9]*}` since #4748; `%%.*` before it);
|
||||
// a digit-run value can never contain a dot OR a letter, so base-10
|
||||
// arithmetic on it can never hit the #4619 / #4748 error classes. Any
|
||||
// name ending in `_INT` (case-insensitive) is that established "already
|
||||
// reduced to a safe integer" convention. That convention is a NAME, not
|
||||
// a proof — `findDotOnlyIntegerSplitDrift` below polices that the split
|
||||
// producing it actually stops at the first non-digit.
|
||||
// 3. `$((10#{plan_padded}))` / `$((10#${PLAN_ID}))` — plan ids are plain
|
||||
// integers and were never in scope; this rule only polices variables
|
||||
// that carry a *phase* id.
|
||||
@@ -449,6 +452,144 @@ function scanMarkdownLetterlessPhaseMirror(root) {
|
||||
return violations;
|
||||
}
|
||||
|
||||
// #4748 (epic #4634): three shell shapes OUTSIDE the grammar-mirror family the
|
||||
// rules above police — consumers of a phase id rather than regexes for one —
|
||||
// each of which the letter axis broke while every rule above reported clean:
|
||||
//
|
||||
// a. `PHASE_INT=${PHASE_NUMBER%%.*}` — the post-#4619 dot-only split. The
|
||||
// `_INT` name it produces satisfies the shell-arithmetic rule's escape,
|
||||
// but on `03A` the "integer" is `03A` and `$((10#03A))` aborts. The safe
|
||||
// split stops at the first NON-digit: `${PHASE_NUMBER%%[!0-9]*}`.
|
||||
// b. `[0-9]+\.?[0-9]*` (and `\d+\.?\d*`) — a digit-then-optional-dot
|
||||
// extraction that is neither the bounded `(\.[0-9]+)?` shape the
|
||||
// single-segment rule bans nor the unbounded `(\.[0-9]+)*` shape the
|
||||
// letterless rule inspects, so both were blind to it. It captures `12`
|
||||
// from `12A` and `23.1` from `23.1.2`, silently.
|
||||
// c. `printf "%02d" "$PHASE_NUMBER"` — re-padding the whole id in shell.
|
||||
// Rejects a letter id (prints `03`, exit 1) and misreads an already
|
||||
// padded `08` as octal (prints `00`). Padding belongs to the canonical
|
||||
// normalizer (`padded_phase` from init, or `normalizePhaseName`); the one
|
||||
// legitimate shell pad is of an `_INT` value via `$((10#…))`.
|
||||
//
|
||||
// Same sanction as the other markdown rules: `<!-- phase-id-owner: … -->` on
|
||||
// the nearest preceding non-blank line. Same documented limit: a per-line
|
||||
// textual scan for the common accidental shape, not an obfuscated one.
|
||||
|
||||
// a. `<name>_INT=${<phase-carrying>%%.*}` — the `_INT` destination is the
|
||||
// discriminator, deliberately: it is the name the shell-arithmetic rule
|
||||
// trusts as "already a safe integer", so a dot-only split INTO it is the
|
||||
// exact promise this rule exists to check. A dot-only split into any other
|
||||
// name is a different, legitimate operation — `PARENT_PHASE="${PHASE_NUMBER%%.*}"`
|
||||
// (gap-closure-artifacts.md) wants everything before the first dot, letter
|
||||
// included, and is correct. Widening to any destination was tried and flagged
|
||||
// that site. The optional quote after `=` is the one spelling that site uses.
|
||||
const DOT_ONLY_INT_SPLIT_DRIFT_RE = /[A-Za-z0-9_]*_INT="?\$\{([A-Za-z0-9_]+)%%\\?\.\*\}/i;
|
||||
|
||||
/**
|
||||
* Pure: find every unsanctioned dot-only integer split of a phase-carrying
|
||||
* variable in `text`. Skips full-line `#` comments (prose). Returns [{ line, found }].
|
||||
*/
|
||||
function findDotOnlyIntegerSplitDrift(text) {
|
||||
const out = [];
|
||||
const lines = text.split('\n');
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
if (/^\s*#/.test(line)) continue;
|
||||
const m = DOT_ONLY_INT_SPLIT_DRIFT_RE.exec(line);
|
||||
if (!m) continue;
|
||||
if (!/phase/i.test(m[1])) continue;
|
||||
if (isSanctionedByPrecedingComment(lines, i, MD_OWNER_RE)) continue;
|
||||
out.push({ line: i + 1, found: m[0] });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// b. The digit-then-optional-dot shape, in both `[0-9]` and `\d` spellings.
|
||||
// Anchored on the trailing `*` of the second digit class so a bare `[0-9]+`
|
||||
// probe or a `[0-9]+\.[0-9]+` (mandatory-dot) shape is not matched.
|
||||
const LOOSE_DOTTED_PHASE_DRIFT_RE = /(?:\\{1,2}d|\[0-9\])\+\\{1,2}\.\?(?:\\{1,2}d|\[0-9\])\*/;
|
||||
|
||||
/**
|
||||
* Pure: find every unsanctioned `[0-9]+\.?[0-9]*`-shaped phase extraction in
|
||||
* `text`, restricted to phase-carrying lines like its two sibling regex rules.
|
||||
* Returns [{ line, found }].
|
||||
*/
|
||||
function findLooseDottedPhaseRegexDrift(text) {
|
||||
const out = [];
|
||||
const lines = text.split('\n');
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
const m = LOOSE_DOTTED_PHASE_DRIFT_RE.exec(line);
|
||||
if (!m) continue;
|
||||
if (!PHASE_CARRYING_LINE_RE.test(line)) continue;
|
||||
if (isSanctionedByPrecedingComment(lines, i, MD_OWNER_RE)) continue;
|
||||
out.push({ line: i + 1, found: m[0] });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// c. `printf "%Nd" …` / `printf '%0Nd' …` — any integer conversion, either
|
||||
// quote, with or without the zero flag — whose argument list names a
|
||||
// phase-carrying variable that is NOT an `_INT` (the `$((10#$PHASE_INT))`
|
||||
// pad is the sanctioned shape). `%d` cannot parse a letter id under any
|
||||
// width, so the flag is not the discriminator. Captures the first such name
|
||||
// so the report says what was padded.
|
||||
const SHELL_PHASE_PRINTF_PAD_RE = /printf\s+(?:"%0?\d*d[^"]*"|'%0?\d*d[^']*')\s+(.*)$/;
|
||||
const SHELL_VAR_NAME_RE = /\$\{?([A-Za-z_][A-Za-z0-9_]*)/g;
|
||||
|
||||
/**
|
||||
* Pure: find every unsanctioned `printf "%02d"` re-pad of a phase-carrying,
|
||||
* non-`_INT` shell variable in `text`. Skips full-line `#` comments.
|
||||
* Returns [{ line, found }].
|
||||
*/
|
||||
function findShellPhasePrintfPadDrift(text) {
|
||||
const out = [];
|
||||
const lines = text.split('\n');
|
||||
for (let i = 0; i < lines.length; i++) {
|
||||
const line = lines[i];
|
||||
if (/^\s*#/.test(line)) continue;
|
||||
const m = SHELL_PHASE_PRINTF_PAD_RE.exec(line);
|
||||
if (!m) continue;
|
||||
const offender = [...m[1].matchAll(SHELL_VAR_NAME_RE)]
|
||||
.map((v) => v[1])
|
||||
.find((name) => /phase/i.test(name) && !/_int$/i.test(name));
|
||||
if (!offender) continue;
|
||||
if (isSanctionedByPrecedingComment(lines, i, MD_OWNER_RE)) continue;
|
||||
out.push({ line: i + 1, found: `printf "%0…d" …$${offender}` });
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan the shell roots (`gsd-core/workflows/**\/*.md`, `gsd-core/references/**\/*.md`)
|
||||
* for the two shell-idiom rules (a, c) and the three regex roots (those plus
|
||||
* `agents/**\/*.md`) for the extraction-shape rule (b). Returns
|
||||
* [{ file, kind, line, found }] with repo-relative paths.
|
||||
*/
|
||||
function scanMarkdownLetterAxisConsumers(root) {
|
||||
const violations = [];
|
||||
const collect = (dirs, finder, kind) => {
|
||||
for (const dir of dirs) {
|
||||
for (const file of walkMd(path.join(root, dir), [])) {
|
||||
const rel = path.relative(root, file);
|
||||
let text;
|
||||
try {
|
||||
text = fs.readFileSync(file, 'utf8');
|
||||
} catch {
|
||||
continue;
|
||||
}
|
||||
for (const d of finder(text)) {
|
||||
violations.push({ file: rel, kind, ...d });
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
collect(MD_SCAN_DIRS, findDotOnlyIntegerSplitDrift, 'dot-only-int-split');
|
||||
collect(SINGLE_SEGMENT_SCAN_DIRS, findLooseDottedPhaseRegexDrift, 'loose-dotted-phase-regex');
|
||||
collect(MD_SCAN_DIRS, findShellPhasePrintfPadDrift, 'shell-phase-printf-pad');
|
||||
return violations;
|
||||
}
|
||||
|
||||
// Authored TypeScript source only (the generated bin/lib/*.cjs mirror it).
|
||||
const SCAN_DIRS = ['src'];
|
||||
const SCAN_EXT = new Set(['.cts', '.ts', '.mts']);
|
||||
@@ -602,6 +743,7 @@ function scanAll(root) {
|
||||
...scanMarkdownShellArith(root),
|
||||
...scanMarkdownSingleSegmentPhaseRegex(root),
|
||||
...scanMarkdownLetterlessPhaseMirror(root),
|
||||
...scanMarkdownLetterAxisConsumers(root),
|
||||
];
|
||||
}
|
||||
|
||||
@@ -631,6 +773,11 @@ function main() {
|
||||
process.stderr.write('A digit-only unbounded-segment phase regex `[0-9]+(\\.[0-9]+)*` on the same roots\n');
|
||||
process.stderr.write('is missing the canonical letter axis (#4660) — widen to `[0-9]+[A-Z]?(\\.[0-9]+)*`\n');
|
||||
process.stderr.write('or sanction with `<!-- phase-id-owner: <reason> -->`.\n');
|
||||
process.stderr.write('Three letter-hostile consumers of a phase id are banned on the same roots (#4748):\n');
|
||||
process.stderr.write('a dot-only integer split `X_INT=${PHASE%%.*}` (split at the first non-digit,\n');
|
||||
process.stderr.write('`${PHASE%%[!0-9]*}`); a `[0-9]+\\.?[0-9]*` extraction (use `[0-9]+[A-Z]?(\\.[0-9]+)*`);\n');
|
||||
process.stderr.write('and a `printf "%02d"` re-pad of a phase variable (bind init\'s `padded_phase`, or pad\n');
|
||||
process.stderr.write('only an `_INT` via `$((10#…))`) — or sanction with `<!-- phase-id-owner: <reason> -->`.\n');
|
||||
process.stderr.write('A `.replace(\'{slug}\', ... || \'phase\')` fallback is banned outright (#4126) —\n');
|
||||
process.stderr.write('use `renderPhaseBranchName(` or sanction with\n');
|
||||
process.stderr.write('`// phase-id-owner: <reason>` on the line directly above:\n');
|
||||
@@ -650,9 +797,13 @@ module.exports = {
|
||||
findShellPhaseArithDrift,
|
||||
findSingleSegmentPhaseRegexDrift,
|
||||
findLetterlessPhaseMirrorDrift,
|
||||
findDotOnlyIntegerSplitDrift,
|
||||
findLooseDottedPhaseRegexDrift,
|
||||
findShellPhasePrintfPadDrift,
|
||||
scanMarkdownShellArith,
|
||||
scanMarkdownSingleSegmentPhaseRegex,
|
||||
scanMarkdownLetterlessPhaseMirror,
|
||||
scanMarkdownLetterAxisConsumers,
|
||||
scanRepo,
|
||||
scanAll,
|
||||
countSelectorBaselines,
|
||||
@@ -664,4 +815,7 @@ module.exports = {
|
||||
SHELL_PHASE_ARITH_DRIFT_RE,
|
||||
SINGLE_SEGMENT_PHASE_DRIFT_RE,
|
||||
LETTERLESS_PHASE_MIRROR_DRIFT_RE,
|
||||
DOT_ONLY_INT_SPLIT_DRIFT_RE,
|
||||
LOOSE_DOTTED_PHASE_DRIFT_RE,
|
||||
SHELL_PHASE_PRINTF_PAD_RE,
|
||||
};
|
||||
|
||||
Reference in New Issue
Block a user