@hominis/fireforge 0.46.0 → 0.46.2

package/dist/src/commands/re-export-drift.d.ts

@@ -2,21 +2,21 @@
  * Foreign-drift preview + `--refuse-foreign-drift` gate for `re-export`.
  *
  * A scan-less re-export rebuilds each patch body as a whole-file
- * `git diff HEAD` over the owned files — so a CONCURRENT session's
+ * `git diff HEAD` over the owned files, so a concurrent session's
  * uncommitted lines inside a file the patch already owns are silently
  * absorbed into the refreshed body. The adjacency advisory
- * (`re-export-adjacent.ts`) warns about unmanaged NEIGHBOUR files but is
+ * (`re-export-adjacent.ts`) warns about unmanaged neighbour files but is
  * structurally blind to drift inside owned files. This module compares
  * the old body against the refreshed body per file and reports the
- * payload lines that are about to ENTER the body; under
+ * payload lines that are about to enter the body. Under
  * `--refuse-foreign-drift` the patch is skipped and the run exits
  * non-zero, mirroring `--refuse-adjacent-unmanaged`.
  *
  * "Foreign" is decided by content, not authorship: re-export's legitimate
  * job is capturing intentional engine edits, so the preview always prints
  * and the hard stop is an explicit opt-in for multi-session checkouts.
- * The comparison is offset-insensitive — per-file MULTISETS of `+`/`-`
- * payload lines — because a refresh legitimately shifts hunk offsets and
+ * The comparison is offset-insensitive, using per-file multisets of `+`/`-`
+ * payload lines, because a refresh legitimately shifts hunk offsets and
  * context without changing what the patch does.
  */
 import type { PatchMetadata } from '../types/commands/index.js';
@@ -55,14 +55,14 @@ export interface FileForeignDrift {
 }
 /**
  * Pure comparison: per owned file, which `+`/`-` payload lines the
- * refreshed body carries that the old body did not. Files NOT in
- * `previousFilesAffected` are skipped — those are intentional adoptions
- * (`--scan`), not drift.
+ * refreshed body carries that the old body did not. Files not in
+ * `previousFilesAffected` are skipped, since those are intentional
+ * adoptions (`--scan`) rather than drift.
  */
 export declare function computeForeignDrift(oldBody: string, newBody: string, previousFilesAffected: readonly string[]): FileForeignDrift[];
 /**
  * Reads the old body, prints the always-on drift preview (including under
- * dry-run and `--scan`), and — when `ctx.refuseForeignDrift` is set —
+ * dry-run and `--scan`), and, when `ctx.refuseForeignDrift` is set,
  * records a refusal and returns `true` so the caller skips the write.
  */
 export declare function reportForeignDrift(args: {
@@ -75,7 +75,7 @@ export declare function reportForeignDrift(args: {
 /**
  * Names `--expect` paths that never drifted this run. A typo'd
  * `--expect` path silently degrades the flag back to refusing the slice it
- * was meant to admit, so surface the mismatch — but only as a warning: an
+ * was meant to admit, so surface the mismatch, but only as a warning: an
  * expected file legitimately shows no drift in several shapes, all named
  * below.
  */

package/dist/src/commands/re-export-drift.js

@@ -3,21 +3,21 @@
  * Foreign-drift preview + `--refuse-foreign-drift` gate for `re-export`.
  *
  * A scan-less re-export rebuilds each patch body as a whole-file
- * `git diff HEAD` over the owned files — so a CONCURRENT session's
+ * `git diff HEAD` over the owned files, so a concurrent session's
  * uncommitted lines inside a file the patch already owns are silently
  * absorbed into the refreshed body. The adjacency advisory
- * (`re-export-adjacent.ts`) warns about unmanaged NEIGHBOUR files but is
+ * (`re-export-adjacent.ts`) warns about unmanaged neighbour files but is
  * structurally blind to drift inside owned files. This module compares
  * the old body against the refreshed body per file and reports the
- * payload lines that are about to ENTER the body; under
+ * payload lines that are about to enter the body. Under
  * `--refuse-foreign-drift` the patch is skipped and the run exits
  * non-zero, mirroring `--refuse-adjacent-unmanaged`.
  *
  * "Foreign" is decided by content, not authorship: re-export's legitimate
  * job is capturing intentional engine edits, so the preview always prints
  * and the hard stop is an explicit opt-in for multi-session checkouts.
- * The comparison is offset-insensitive — per-file MULTISETS of `+`/`-`
- * payload lines — because a refresh legitimately shifts hunk offsets and
+ * The comparison is offset-insensitive, using per-file multisets of `+`/`-`
+ * payload lines, because a refresh legitimately shifts hunk offsets and
  * context without changing what the patch does.
  */
 import { stat } from 'node:fs/promises';
@@ -115,9 +115,9 @@ function countExcess(excess) {
 }
 /**
  * Pure comparison: per owned file, which `+`/`-` payload lines the
- * refreshed body carries that the old body did not. Files NOT in
- * `previousFilesAffected` are skipped — those are intentional adoptions
- * (`--scan`), not drift.
+ * refreshed body carries that the old body did not. Files not in
+ * `previousFilesAffected` are skipped, since those are intentional
+ * adoptions (`--scan`) rather than drift.
  */
 export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
     const owned = new Set(previousFilesAffected);
@@ -156,7 +156,7 @@ export function computeForeignDrift(oldBody, newBody, previousFilesAffected) {
 }
 /**
  * Reads the old body, prints the always-on drift preview (including under
- * dry-run and `--scan`), and — when `ctx.refuseForeignDrift` is set —
+ * dry-run and `--scan`), and, when `ctx.refuseForeignDrift` is set,
  * records a refusal and returns `true` so the caller skips the write.
  */
 export async function reportForeignDrift(args) {
@@ -225,13 +225,13 @@ export async function reportForeignDrift(args) {
 /**
  * Splits the drifting files into "you probably wrote this" and "this predates
  * your last export". `--refuse-foreign-drift` calls every absorbed line
- * "foreign" — including the operator's OWN additions from the same session —
- * and "foreign" reads as "another session's", which is precisely the case
- * where proceeding would be wrong. Authorship is unknowable, but RECENCY is
- * not: a file whose mtime is newer than the patch body this run is refreshing
+ * "foreign", including the operator's own additions from the same session,
+ * and "foreign" reads as "another session's", which is the case where
+ * proceeding would be wrong. Authorship is unknowable, but recency is not:
+ * a file whose mtime is newer than the patch body this run is refreshing
  * changed after the last export, which on a single-operator slice is the
- * operator's own edit. Returns the subset of `files` that qualifies; an
- * unstattable path is reported as NOT recently edited, so the cautious
+ * operator's own edit. Returns the subset of `files` that qualifies. An
+ * unstattable path is reported as not recently edited, so the cautious
  * wording is the fallback.
  */
 async function findFilesEditedSinceLastExport(engineDir, patchBodyPath, files) {
@@ -257,7 +257,7 @@ async function findFilesEditedSinceLastExport(engineDir, patchBodyPath, files) {
 }
 /**
  * Fail-closed baseline handling: a missing or unreadable old
- * patch body means the drift comparison CANNOT run, so under
+ * patch body means the drift comparison cannot run, so under
  * `--refuse-foreign-drift` the patch is refused rather than written on the
  * strength of a check that never happened. Without the flag this stays the
  * historical advisory skip (the preview is best-effort there).
@@ -272,28 +272,28 @@ function refuseUnreadableBaseline(ctx, patchFilename, detail) {
     return true;
 }
 /**
- * States, verbatim in the notice, WHAT the `--expect` whitelist is compared
- * against and WHEN. This notice is the only feedback an operator gets that
+ * States, verbatim in the notice, what the `--expect` whitelist is compared
+ * against and when. This notice is the only feedback an operator gets that
  * the drift belt looked at the files they named, and a downstream report
  * showed the previous copy actively misleading: it warned "showed no drift"
- * over an edit that WAS captured correctly, and none of the causes it named
+ * over an edit that was captured correctly, and none of the causes it named
  * held, so the operator's only recourse was `grep -c` on the written body.
  *
  * The measurement, stated exactly:
  *
- *  - COMPARED: for each file already in the patch's `filesAffected`, the
- *    `+`/`-` payload lines the REFRESHED body carries that the OLD patch
+ *  - Compared: for each file already in the patch's `filesAffected`, the
+ *    `+`/`-` payload lines the refreshed body carries that the old patch
  *    body did not (`computeForeignDrift`). It is a content comparison, and
- *    it is ONE-DIRECTIONAL: excess in the new body only.
- *  - WHEN: per patch, on the body about to be written, BEFORE the write —
- *    never against post-write state.
+ *    it is one-directional: excess in the new body only.
+ *  - When: per patch, on the body about to be written, before the write.
+ *    Never against post-write state.
  *
  * The one-directional half is what the earlier copy hid, and it is the
  * cause the report's first shape actually hit: deleting a line from an
- * engine file makes the refreshed body DROP that file's `+` line. Nothing
- * is absorbed, so by design there is no drift to see — the belt exists to
- * catch a concurrent session's edits being silently swallowed INTO a body,
- * not every difference between two bodies. Naming it is the fix; widening
+ * engine file makes the refreshed body drop that file's `+` line. Nothing
+ * is absorbed, so there is no drift to see. The belt exists to catch a
+ * concurrent session's edits being silently swallowed into a body, not
+ * every difference between two bodies. Stating that is the fix. Widening
  * the comparison would turn every ordinary line removal into a refusal.
  */
 const EXPECT_MEASUREMENT_NOTE = '--expect is evaluated against CONTENT, before the write: for each file already in the ' +
@@ -302,7 +302,7 @@ const EXPECT_MEASUREMENT_NOTE = '--expect is evaluated against CONTENT, before t
 /**
  * Names `--expect` paths that never drifted this run. A typo'd
  * `--expect` path silently degrades the flag back to refusing the slice it
- * was meant to admit, so surface the mismatch — but only as a warning: an
+ * was meant to admit, so surface the mismatch, but only as a warning: an
  * expected file legitimately shows no drift in several shapes, all named
  * below.
  */

package/dist/src/commands/re-export-files.js

@@ -19,9 +19,9 @@ import { projectEntryBody } from './patch/entry-projection.js';
  * Computes the effective `tier` and `lintIgnore` carrying both the patch's
  * existing values and the CLI flag overrides.
  *
- * Tier resolution: the CLI flag takes precedence; the patch's existing tier
+ * Tier resolution: the CLI flag takes precedence. The patch's existing tier
  * is the fallback. Lint-ignore resolution: union of the patch's existing list
- * and the CLI flag values, de-duplicated; an empty result returns `undefined`
+ * and the CLI flag values, de-duplicated. An empty result returns `undefined`
  * so the caller can drop the field rather than write an empty array.
  */
 function resolveEffectiveTierAndLintIgnore(target, options) {
@@ -110,7 +110,7 @@ async function confirmFilesModeProjection(args) {
         title: `Re-export ${target.filename} with --files`,
         summary,
         // A captured deletion still needs the confirmation: the patch will now
-        // REMOVE those files wherever it is applied, which is the same class of
+        // remove those files wherever it is applied, which is the same class of
         // consequence as shrinking the scope.
         yes: removed.length === 0 && deletedFiles.length === 0 ? true : options.yes === true,
         dryRun: isDryRun,
@@ -122,13 +122,13 @@ async function confirmFilesModeProjection(args) {
  * Splits the requested paths into what can be diffed and what is a deletion.
  *
  * A path absent from disk is one of two very different things, and
- * collapsing them is what made a DELETION impossible to capture.
+ * collapsing them is what made a deletion impossible to capture.
  *
  * Tracked in HEAD: a deletion. `git diff HEAD -- <path>` renders it as a
- * proper `deleted file mode` section, so it STAYS in the diff scope. (The
- * comment this replaces claimed the diff "would fail" on any missing path —
- * true only for the never-tracked case.) Dropping these produced the
- * dangerous shape: a re-export that reported success while writing a patch
+ * proper `deleted file mode` section, so it stays in the diff scope. (The
+ * comment this replaces claimed the diff "would fail" on any missing path,
+ * which is true only for the never-tracked case.) Dropping these produced
+ * the dangerous shape: a re-export that reported success while writing a patch
  * whose own file list claimed a path it did not restore, so a fresh clone
  * would apply it and resurrect exactly what the change meant to remove.
  *
@@ -185,8 +185,8 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
     }
     const requested = [...new Set(filesOption)].sort();
-    // Stale-furnace-source gate: same refusal as the generic re-export path —
-    // the projected diff would capture stale deployed copies.
+    // Stale-furnace-source gate: same refusal as the generic re-export path,
+    // since the projected diff would capture stale deployed copies.
     await enforceFreshFurnaceSources(paths.root, requested, options.allowStaleFurnace === true, 're-export');
     const removed = target.filesAffected.filter((f) => !requested.includes(f));
     const added = requested.filter((f) => !target.filesAffected.includes(f));
@@ -203,12 +203,11 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     }
     const actualProjectedFiles = extractAffectedFiles(projectedDiff);
     const actualProjectedSet = new Set(actualProjectedFiles);
-    // Domain is the FULL requested list, not the diffable subset. When the
+    // Domain is the full requested list, not the diffable subset. When the
     // subset was used, any path filtered out upstream was invisible to this
-    // check by construction — which is exactly how a dropped deletion slipped
-    // through while the run reported success. A patch that does not do what
-    // its own file list claims is the one property a manifest must never get
-    // wrong, so an explicitly named path that produced no hunk is a refusal.
+    // check, which is how a dropped deletion slipped through while the run
+    // reported success. A patch must do what its own file list claims, so an
+    // explicitly named path that produced no hunk is a refusal.
     const noDiffFiles = requested.filter((file) => !actualProjectedSet.has(file));
     if (noDiffFiles.length > 0) {
         throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because ${noDiffFiles.length} requested path${noDiffFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffFiles.join(', ')}). ` +

package/dist/src/commands/re-export-lint.d.ts

@@ -1,21 +1,21 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * Rebuilding the whole patch-queue context and a fresh queue-wide checkJs
  * TypeScript program for every patch costs tens of seconds of fixed setup
  * per patch, so an N-patch re-export pays it N times. This module:
  *
- * - builds the queue context and the {@link PerRunCheckJs} program
- *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- *   per-patch findings out of it;
- * - reuses the existing per-patch lint RESULT cache
- *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
+ * - Builds the queue context and the {@link PerRunCheckJs} program
+ *   controller once per invocation (`buildReExportLintContext`) and slices
+ *   per-patch findings out of it.
+ * - Reuses the existing per-patch lint result cache
+ *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations, since
  *   re-export lints the identical input `lint --per-patch` does (the fresh
  *   `git diff HEAD` of the owned files), and the key already hashes engine
  *   HEAD, per-file content, patch body, config, shims, and ownership, so a
- *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
- *   checkJs globals are never cached and are emitted once per invocation;
- * - keeps the in-memory queue context honest after each write
+ *   repeat single re-export is a warm hit. `--no-cache` opts out. Run-level
+ *   checkJs globals are never cached and are emitted once per invocation.
+ * - Keeps the in-memory queue context honest after each write
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
@@ -29,12 +29,12 @@ export interface ReExportLintContext {
     projectRoot: string;
     paths: ProjectPaths;
     config: FireForgeConfig;
-    /** Whole-queue context, built WITH config so the forward-import hints
-     * match `lint --per-patch`; undefined when no patches dir. */
+    /** Whole-queue context, built with config so the forward-import hints
+     * match `lint --per-patch`. Undefined when no patches dir. */
     patchQueueCtx: PatchQueueContext | undefined;
-    /** Queue-wide checkJs controller; undefined when checkJs is off. */
+    /** Queue-wide checkJs controller. Undefined when checkJs is off. */
     checkJs: PerRunCheckJs | undefined;
-    /** Per-patch result cache; undefined under `--no-cache`. */
+    /** Per-patch result cache. Undefined under `--no-cache`. */
     cache: PerPatchLintCacheFile | undefined;
     engineHeadSha: string | undefined;
     cacheDirty: boolean;
@@ -53,20 +53,20 @@ export interface ReExportLintResult {
     lintIgnore: string[];
 }
 /**
- * Lints one re-exported patch body using the hoisted context: cache hit →
- * replay the stored issues through the shared reporter (returns `null`);
- * miss → lint with the queue-wide program's pre-attributed slices (or a
+ * Lints one re-exported patch body using the hoisted context. A cache hit
+ * replays the stored issues through the shared reporter and returns `null`.
+ * A miss lints with the queue-wide program's pre-attributed slices (or a
  * per-patch build when the fresh diff creates files the hoisted program
- * never saw — the `--scan` adoption case) and return the payload for
+ * never saw, the `--scan` adoption case) and returns the payload for
  * {@link storeReExportLintResult}. Throws exactly like `runPatchLint` on
  * errors (unless `skipLint`).
  *
- * The cache key is built over the PROJECTED metadata (current
+ * The cache key is built over the projected metadata (current
  * filesAffected, merged lintIgnore, effective tier) so `--tier` /
- * `--lint-ignore` flags change the key. The entry itself is stored AFTER
- * the body write (the key hashes the on-disk `.patch` file, which this
- * very run is about to rewrite — a pre-write store could never match a
- * later run).
+ * `--lint-ignore` flags change the key. The entry itself is stored after
+ * the body write, because the key hashes the on-disk `.patch` file that
+ * this very run is about to rewrite, so a pre-write store could never
+ * match a later run.
  */
 export declare function lintReExportedPatch(args: {
     lintCtx: ReExportLintContext;
@@ -79,16 +79,16 @@ export declare function lintReExportedPatch(args: {
     patchTier?: 'branding';
 }): Promise<ReExportLintResult | null>;
 /**
- * Stores a fresh lint result AFTER the body write, keying against the
- * just-written `.patch` file and the refreshed queue context — the state
- * a later identical invocation will observe (call
+ * Stores a fresh lint result after the body write, keying against the
+ * just-written `.patch` file and the refreshed queue context, which is the
+ * state a later identical invocation will observe (call
  * {@link refreshQueueCtxEntry} first).
  */
 export declare function storeReExportLintResult(lintCtx: ReExportLintContext, patchFilename: string, projectedMetadata: PatchMetadata, existingFiles: string[], result: ReExportLintResult): Promise<void>;
 /**
  * Refreshes the in-memory queue entry for a just-rewritten patch so later
  * iterations (and later cache keys) lint against the new body instead of
- * the stale one. The on-disk write is the authority; this mirrors it.
+ * the stale one. The on-disk write is the authority. This mirrors it.
  */
 export declare function refreshQueueCtxEntry(lintCtx: ReExportLintContext, patchFilename: string, diffContent: string): void;
 /** Persists cache writes and reports reuse, once after the loop. */

package/dist/src/commands/re-export-lint.js

@@ -2,21 +2,21 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * Rebuilding the whole patch-queue context and a fresh queue-wide checkJs
  * TypeScript program for every patch costs tens of seconds of fixed setup
  * per patch, so an N-patch re-export pays it N times. This module:
  *
- * - builds the queue context and the {@link PerRunCheckJs} program
- *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- *   per-patch findings out of it;
- * - reuses the existing per-patch lint RESULT cache
- *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
+ * - Builds the queue context and the {@link PerRunCheckJs} program
+ *   controller once per invocation (`buildReExportLintContext`) and slices
+ *   per-patch findings out of it.
+ * - Reuses the existing per-patch lint result cache
+ *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations, since
  *   re-export lints the identical input `lint --per-patch` does (the fresh
  *   `git diff HEAD` of the owned files), and the key already hashes engine
  *   HEAD, per-file content, patch body, config, shims, and ownership, so a
- *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
- *   checkJs globals are never cached and are emitted once per invocation;
- * - keeps the in-memory queue context honest after each write
+ *   repeat single re-export is a warm hit. `--no-cache` opts out. Run-level
+ *   checkJs globals are never cached and are emitted once per invocation.
+ * - Keeps the in-memory queue context honest after each write
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
@@ -62,26 +62,26 @@ function checkJsFilesInDiff(diffContent, checkJs) {
     return files;
 }
 /**
- * Lints one re-exported patch body using the hoisted context: cache hit →
- * replay the stored issues through the shared reporter (returns `null`);
- * miss → lint with the queue-wide program's pre-attributed slices (or a
+ * Lints one re-exported patch body using the hoisted context. A cache hit
+ * replays the stored issues through the shared reporter and returns `null`.
+ * A miss lints with the queue-wide program's pre-attributed slices (or a
  * per-patch build when the fresh diff creates files the hoisted program
- * never saw — the `--scan` adoption case) and return the payload for
+ * never saw, the `--scan` adoption case) and returns the payload for
  * {@link storeReExportLintResult}. Throws exactly like `runPatchLint` on
  * errors (unless `skipLint`).
  *
- * The cache key is built over the PROJECTED metadata (current
+ * The cache key is built over the projected metadata (current
  * filesAffected, merged lintIgnore, effective tier) so `--tier` /
- * `--lint-ignore` flags change the key. The entry itself is stored AFTER
- * the body write (the key hashes the on-disk `.patch` file, which this
- * very run is about to rewrite — a pre-write store could never match a
- * later run).
+ * `--lint-ignore` flags change the key. The entry itself is stored after
+ * the body write, because the key hashes the on-disk `.patch` file that
+ * this very run is about to rewrite, so a pre-write store could never
+ * match a later run.
  */
 export async function lintReExportedPatch(args) {
     const { lintCtx, patch, projectedMetadata, existingFiles, diffContent } = args;
     const { paths, config, patchQueueCtx, checkJs, cache } = lintCtx;
-    // Tier notice, identical to runPatchLint's head — surfaced on both the
-    // cached and fresh paths so the governing tier is never silent.
+    // Tier notice, identical to runPatchLint's head. It is surfaced on both
+    // the cached and fresh paths so the governing tier is never silent.
     const tierDecision = resolvePatchSizeTier(existingFiles, args.patchTier);
     if (tierDecision.tier === 'branding') {
         info(tierDecision.source === 'explicit'
@@ -126,8 +126,8 @@ export async function lintReExportedPatch(args) {
         }
         else {
             // Fresh `--scan` adoption created checkJs-relevant files the hoisted
-            // program has never seen — fall back to a per-patch build with the
-            // usual report scope so nothing is silently unchecked.
+            // program has never seen, so fall back to a per-patch build with the
+            // usual report scope and nothing is silently unchecked.
             lintOptions.checkJsReportScope = resolvePatchOwnedSysMjs(detectNewFilesInDiff(diffContent));
         }
     }
@@ -149,9 +149,9 @@ export async function lintReExportedPatch(args) {
     };
 }
 /**
- * Stores a fresh lint result AFTER the body write, keying against the
- * just-written `.patch` file and the refreshed queue context — the state
- * a later identical invocation will observe (call
+ * Stores a fresh lint result after the body write, keying against the
+ * just-written `.patch` file and the refreshed queue context, which is the
+ * state a later identical invocation will observe (call
  * {@link refreshQueueCtxEntry} first).
  */
 export async function storeReExportLintResult(lintCtx, patchFilename, projectedMetadata, existingFiles, result) {
@@ -182,7 +182,7 @@ export async function storeReExportLintResult(lintCtx, patchFilename, projectedM
 /**
  * Refreshes the in-memory queue entry for a just-rewritten patch so later
  * iterations (and later cache keys) lint against the new body instead of
- * the stale one. The on-disk write is the authority; this mirrors it.
+ * the stale one. The on-disk write is the authority. This mirrors it.
  */
 export function refreshQueueCtxEntry(lintCtx, patchFilename, diffContent) {
     const ctx = lintCtx.patchQueueCtx;
@@ -198,7 +198,7 @@ export function refreshQueueCtxEntry(lintCtx, patchFilename, diffContent) {
     const modifiedFileAdditions = new Map();
     for (const [file, lines] of addedLinesByFile) {
         if (newFilePaths.has(file)) {
-            // A created file's content IS its added lines.
+            // A created file's content is its added lines.
             newFiles.set(file, lines.join('\n'));
         }
         else {

package/dist/src/commands/re-export-options.d.ts

@@ -11,7 +11,7 @@ export interface NormalizedReExportArguments {
  * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
  * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
  * `c/d.js` in the positional patches and fails with "--files operates on
- * exactly one target patch" — pointing at the wrong argument. When every
+ * exactly one target patch", pointing at the wrong argument. When every
  * positional beyond the first looks like a file path, fold them into the
  * file list.
  */

package/dist/src/commands/re-export-options.js

@@ -14,7 +14,7 @@ function looksLikeFilePath(value) {
  * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
  * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
  * `c/d.js` in the positional patches and fails with "--files operates on
- * exactly one target patch" — pointing at the wrong argument. When every
+ * exactly one target patch", pointing at the wrong argument. When every
  * positional beyond the first looks like a file path, fold them into the
  * file list.
  */

package/dist/src/commands/re-export-register.d.ts

@@ -3,7 +3,7 @@
  *
  * Split out of `re-export.ts`, which was otherwise over the per-file line
  * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
  * the orchestrator would go the wrong way.
  */
 import { Command } from 'commander';

package/dist/src/commands/re-export-register.js

@@ -4,7 +4,7 @@
  *
  * Split out of `re-export.ts`, which was otherwise over the per-file line
  * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
  * the orchestrator would go the wrong way.
  */
 import { Command, Option } from 'commander';

package/dist/src/commands/re-export-scan.d.ts

@@ -30,7 +30,7 @@ export declare function confirmBroadScanAdditions(args: {
 }): Promise<boolean>;
 /**
  * Refuses scan adoptions whose candidate files import modules created by
- * LATER patches. Modeled on the `re-export --files` cross-patch
+ * later patches. Modeled on the `re-export --files` cross-patch
  * projection: the candidates' diffs are projected into the adopting
  * patch's queue entry, the queue lint runs baseline vs projection, and
  * only forward-import regressions attributable to the candidates block.

package/dist/src/commands/re-export-scan.js

@@ -57,10 +57,10 @@ async function scanPatchFiles(args) {
             discoveredFiles.add(f);
     }
     // Git pathspecs recurse, so a claimed file in a shallow directory would
-    // sweep entire subtrees into the candidate set — with several patches
+    // sweep entire subtrees into the candidate set: with several patches
     // sharing a parent directory, every unmanaged file in the tree gets
     // offered to whichever patch is scanned first. Constrain the broad scan
-    // to the patch's exact directory footprint; deeper paths need an
+    // to the patch's exact directory footprint. Deeper paths need an
     // explicit --scan-file / --scan-files assignment.
     const parentDirSet = new Set(parentDirs);
     const currentSet = new Set(currentFilesAffected);
@@ -78,7 +78,7 @@ async function scanPatchFilesTargeted(args) {
     // Phase-split for bounded concurrency: the sync claimed-by-others check
     // first (first offender in argument order, as before), then pooled
     // existence probes with the refusal chosen by ordered iteration so the
-    // FIRST missing file in argument order is named deterministically.
+    // first missing file in argument order is named deterministically.
     for (const file of scanFiles) {
         if (claimedByOthers.has(file)) {
             throw new InvalidArgumentError(`--scan-file path is already claimed by another patch: ${file}`, '--scan-file');
@@ -99,12 +99,12 @@ async function scanPatchFilesTargeted(args) {
     return reportScanResult(currentFilesAffected, patchFilename, isDryRun, added.sort(), removed);
 }
 /**
- * Paths that have genuinely left the patch's ownership: absent from disk AND
+ * Paths that have genuinely left the patch's ownership: absent from disk and
  * untracked in engine HEAD.
  *
- * An absent path that IS tracked in HEAD is a DELETION, not a de-ownership.
+ * An absent path that is tracked in HEAD is a deletion, not a de-ownership.
  * The diff carries it as a `deleted file mode` section, so it must stay in
- * `filesAffected` — pruning it desynchronises the manifest from the patch
+ * `filesAffected`. Pruning it desynchronises the manifest from the patch
  * body in the direction that hurts: the body says "delete this file", the
  * file list says the patch has nothing to do with it.
  */
@@ -161,7 +161,7 @@ function scanAdditionsNeedConfirmation(added) {
 }
 /**
  * Refuses scan adoptions whose candidate files import modules created by
- * LATER patches. Modeled on the `re-export --files` cross-patch
+ * later patches. Modeled on the `re-export --files` cross-patch
  * projection: the candidates' diffs are projected into the adopting
  * patch's queue entry, the queue lint runs baseline vs projection, and
  * only forward-import regressions attributable to the candidates block.

package/dist/src/commands/re-export-single.d.ts

@@ -33,7 +33,7 @@ export interface ReExportSinglePatchArgs {
  * Retries a single patch re-export exactly once when the failure is
  * transient git `index.lock` contention (an external git process holding
  * the engine repo's index). The retry re-enters `reExportSinglePatch`
- * from the top, so it re-reads clean state; a second lock failure
+ * from the top, so it re-reads clean state. A second lock failure
  * propagates to the loop's honest "N of M" accounting.
  */
 export declare function reExportSinglePatchWithIndexLockRetry(args: ReExportSinglePatchArgs): Promise<boolean>;