declapract-typescript-ehmpathy 0.49.9 → 0.49.11

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/bad-practices/package-lock-json/package-lock.json.declapract.integration.test.ts

@@ -0,0 +1,105 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+
+import type { FileCheckContext } from 'declapract';
+import { given, then, useBeforeAll, when } from 'test-fns';
+
+import { check, fix } from './package-lock.json.declapract';
+
+/**
+ * .what = the forget-not-destroy clamp for the package-lock.json bad-practice.
+ * .why  = the fix DELETES the npm lockfile, so it is destructive — `rule.require.clamp-edge-cases`
+ *         demands a regression clamp that BITES. the gate reads the real filesystem for a
+ *         `pnpm-lock.yaml` beside the lockfile, so this is an integration test (a filesystem
+ *         boundary, per `rule.forbid.unit.remote-boundaries`), built on the `mkdtempSync`
+ *         throwaway-root pattern from `howto.craft-practice-migrations`. it proves BOTH paths:
+ *         delete-when-safe (pnpm-lock.yaml present) and skip-when-unsafe (absent) — the second
+ *         guards the forget-not-destroy contract: a bare EXISTS default-delete would fail it.
+ */
+/**
+ * .what = builds the minimal FileCheckContext the check and fix functions actually use
+ * .why  = declapract's FileCheckContext carries many fields the package-lock check/fix never
+ *         touch — they read only `getProjectRootDirectory()` (to look for a `pnpm-lock.yaml`
+ *         beside the lockfile). the single documented cast here is the sanctioned test-context
+ *         idiom (howto.craft-practice-migrations); it is confined to this helper so no call
+ *         site casts. removal path: drop the cast the day declapract exports a partial-context
+ *         builder.
+ */
+const genContextForRoot = (root: string): FileCheckContext =>
+  ({ getProjectRootDirectory: () => root }) as unknown as FileCheckContext;
+
+describe('pnpm package-lock-json — forget-not-destroy gate', () => {
+  // .note = deliberate mutation — `roots` accumulates every temp dir genRoot mints so the
+  //         afterAll below can remove them all; a scoped, single-threaded test-cleanup zone
+  //         (rule.require.immutable-vars sanctions in-place mutation with this note).
+  const roots: string[] = [];
+  const genRoot = (slug: string, files: Record<string, string>): string => {
+    const root = mkdtempSync(path.join(tmpdir(), `pnpm-lock-${slug}-`));
+    for (const [name, body] of Object.entries(files))
+      writeFileSync(path.join(root, name), body);
+    roots.push(root);
+    return root;
+  };
+
+  afterAll(() => {
+    for (const root of roots) rmSync(root, { recursive: true, force: true });
+  });
+
+  given('[case1] a package-lock.json WITH a pnpm-lock.yaml beside it', () => {
+    const state = useBeforeAll(async () => {
+      const root = genRoot('safe', {
+        'package-lock.json': '{}',
+        'pnpm-lock.yaml': 'lockfileVersion: 9\n',
+      });
+      const context = genContextForRoot(root);
+      return { context, fixed: (await fix('{}', context)).contents };
+    });
+
+    when('[t0] the bad-practice is evaluated', () => {
+      then('check detects it — safe to remove', () => {
+        expect(() => check('{}', state.context)).not.toThrow();
+      });
+
+      then('fix removes it — contents become null', () => {
+        expect(state.fixed).toBeNull();
+      });
+    });
+  });
+
+  given('[case2] a package-lock.json with NO pnpm-lock.yaml beside it', () => {
+    const state = useBeforeAll(async () => {
+      const root = genRoot('unsafe', { 'package-lock.json': '{}' });
+      const context = genContextForRoot(root);
+      return { context, fixed: (await fix('{}', context)).contents };
+    });
+
+    when('[t0] the bad-practice is evaluated', () => {
+      then('check skips it — forget-not-destroy, no pnpm-lock.yaml yet', () => {
+        expect(() => check('{}', state.context)).toThrow(
+          'does not match bad practice',
+        );
+      });
+
+      then('fix is a no-op — the npm lockfile is preserved', () => {
+        // a bare EXISTS default-delete would make this null, which this test would catch
+        expect(state.fixed).toEqual('{}');
+      });
+    });
+  });
+
+  given('[case3] no package-lock.json at all', () => {
+    const state = useBeforeAll(async () => {
+      const root = genRoot('absent', { 'pnpm-lock.yaml': 'lockfileVersion: 9\n' });
+      return { context: genContextForRoot(root) };
+    });
+
+    when('[t0] the bad-practice is evaluated', () => {
+      then('check skips it — no npm lockfile to remove', () => {
+        expect(() => check(null, state.context)).toThrow(
+          'does not match bad practice',
+        );
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/bad-practices/package-lock-json/package-lock.json.declapract.ts

@@ -0,0 +1,41 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+
+/**
+ * .what = detects a `package-lock.json` (the npm lockfile) that is SAFE to remove — i.e. only
+ *         once a `pnpm-lock.yaml` sits beside it.
+ * .why  = the npm→pnpm migration must be FORGET-NOT-DESTROY: `package-lock.json` is removed ONLY
+ *         after `pnpm-lock.yaml` exists, so a fix interrupted midway never leaves the repo
+ *         lockfile-less (the wish's stated safety bar). a bare `FileCheckType.EXISTS` would let
+ *         declapract's default fix delete the npm lockfile UNCONDITIONALLY — even on a repo that
+ *         has not yet run `pnpm install` — which is exactly the destructive strip this gate
+ *         forecloses. so the delete is gated on the pnpm lockfile's presence, read from the
+ *         project root via `context.getProjectRootDirectory()`.
+ */
+const hasPnpmLock = (context: {
+  getProjectRootDirectory: () => string;
+}): boolean =>
+  existsSync(path.join(context.getProjectRootDirectory(), 'pnpm-lock.yaml'));
+
+export const check: FileCheckFunction = (contents, context) => {
+  // no package-lock.json → no npm lockfile to remove, skip
+  if (contents === null) throw new Error('does not match bad practice');
+
+  // forget-not-destroy: without a pnpm-lock.yaml beside it, removal would leave the repo
+  // lockfile-less — so this is NOT yet a safe-to-remove npm lockfile, skip
+  if (!hasPnpmLock(context)) throw new Error('does not match bad practice');
+
+  // package-lock.json present AND pnpm-lock.yaml present → safe to remove, detected
+  return;
+};
+
+export const fix: FileFixFunction = (contents, context) => {
+  // gate the delete on the pnpm lockfile's presence (forget-not-destroy) — a fix that ran
+  // where the check would not detect leaves the file untouched, never lockfile-less
+  if (!hasPnpmLock(context)) return { contents };
+
+  // pnpm-lock.yaml exists → remove the redundant npm lockfile
+  return { contents: null };
+};

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/best-practice/.declapract.readme.md

@@ -0,0 +1,22 @@
+# pnpm best-practice — what this practice owns, and what it does NOT
+
+this practice owns the pnpm **adoption** signal: the `packageManager` exact pin
+(`pnpm@10.31.7`, an intentional org-convergence requirement — see the `.declapract.ts` note).
+
+## where the hoisted-linker `.npmrc` lives — NOT here
+
+the pnpm-only `.npmrc` directives an expo repo needs (`node-linker=hoisted`,
+`public-hoist-pattern[]=*expo*`, …) are declared by the **`node`** practice, not this one. the
+`node` practice owns the whole `.npmrc` (it is the package-manager-config file), and its declaration
+is usecase-aware: it findserts the hoist block only when the `cicd-app-react-native-expo` usecase is
+present.
+
+so an auditor of all that pnpm needs should also read:
+
+- `src/practices/node/best-practice/.npmrc.declapract.ts` — the usecase-aware `.npmrc` declaration
+- `src/utils/defineExpectedNpmrcContents.ts` — the shared base + expo-hoist line source
+- `.agent/repo=.this/role=any/briefs/howto.pnpm-expo-hoisted-linker.md` — why the flat linker is
+  required for metro/expo, and the transitive-skew gotcha it exposes
+
+the split is deliberate: the `.npmrc` is one file with one owner (`node`), so a repo gets a single
+coherent `.npmrc` rather than two practices that fight over it.

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/best-practice/package.json

@@ -0,0 +1,3 @@
+{
+  "packageManager": "pnpm@10.31.7"
+}

package/dist/.test/assets/expo-migration/declarations/practices/pnpm/best-practice/package.json.declapract.ts

@@ -0,0 +1,15 @@
+import { FileCheckType } from 'declapract';
+
+/**
+ * .what = pins `packageManager` to an EXACT pnpm version (`pnpm@10.31.7`), not a minVersion.
+ * .why  = this is an intentional org-standardization REQUIREMENT, not an oversight. every pnpm
+ *         consumer runs ONE blessed pnpm version, so `corepack` / `pnpm/action-setup@v4` load the
+ *         identical toolchain across CI, local, and every repo — reproducible installs, no per-repo
+ *         drift. an exact pin is also the ONLY correct shape here: the `packageManager` field is a
+ *         corepack spec that requires the `pnpm@<version>` prefix, which declapract's bare-semver
+ *         `check.minVersion(..)` cannot emit.
+ * .note = a consumer ahead of the pin (e.g. on 10.32.1) is pinned BACK to the blessed version on
+ *         `declapract fix` — that convergence-to-one-version is the intent, not a regression. when
+ *         the org bumps the blessed version, this pin bumps and every consumer follows.
+ */
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/deprecated-use-file/.declapract.readme.md

@@ -0,0 +1,11 @@
+# Deprecated rhachet.use.ts File
+
+This bad practice detects and removes the deprecated `@/rhachet.use.ts` (i.e., `rhachet.use.ts` at repo root) config file.
+
+## Why
+
+The `rhachet.use.ts` config file pattern has been deprecated. Projects should migrate away from this pattern.
+
+## Fix
+
+The fix automatically deletes the file from the repository.

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/deprecated-use-file/rhachet.use.ts.declapract.ts

@@ -0,0 +1,12 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+/**
+ * .what = detects the deprecated @/rhachet.use.ts config file
+ * .why = this config file pattern has been deprecated and should be removed
+ */
+
+export const check = FileCheckType.EXISTS;
+
+export const fix: FileFixFunction = () => {
+  return { contents: null }; // delete the file
+};

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/prod-deps/.declapract.readme.md

@@ -0,0 +1,55 @@
+# rhachet prod-deps bad practice
+
+## what
+
+detects `rhachet` and `rhachet-roles-*` packages listed as production dependencies and moves them to devDependencies.
+
+## why
+
+rhachet packages are build-time / development tooling only. they should never be shipped as production dependencies because:
+
+1. **no runtime usage** — rhachet is used for agent role management, skill linking, and development workflows. none of this runs at runtime in production.
+
+2. **bloated bundles** — including rhachet in prod deps unnecessarily inflates `node_modules` for deployed applications.
+
+3. **dependency hygiene** — packages that are only used during development belong in `devDependencies`. at worst, if downstream packages need them, they should be declared as `peerDependencies`.
+
+## packages covered
+
+- `rhachet`
+- `rhachet-roles-*` (e.g., `rhachet-roles-ehmpathy`, `rhachet-roles-bhrain`, `rhachet-roles-bhuild`)
+
+## fix
+
+moves all matching packages from `dependencies` to `devDependencies`, preserving their versions.
+
+## correct placement
+
+```json
+{
+  "devDependencies": {
+    "rhachet": "^1.19.0",
+    "rhachet-roles-ehmpathy": "^1.15.0"
+  }
+}
+```
+
+or, if downstream packages need to use them:
+
+```json
+{
+  "peerDependencies": {
+    "rhachet": ">=1.0.0"
+  }
+}
+```
+
+never:
+
+```json
+{
+  "dependencies": {
+    "rhachet": "^1.19.0"
+  }
+}
+```

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/prod-deps/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "rhachet": "@declapract{check.minVersion('0.0.0')}"
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/prod-deps/package.json.declapract.ts

@@ -0,0 +1,47 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+
+/**
+ * .what = detects rhachet and rhachet-roles-* packages in production dependencies
+ * .why = these packages should be devDependencies or peerDependencies, never direct prod deps
+ */
+
+const rhachetPackagePattern = /^rhachet(-roles-.*)?$/;
+
+export const check: FileCheckFunction = (contents) => {
+  if (!contents) throw new Error('does not match bad practice');
+
+  const packageJSON = JSON.parse(contents);
+  const prodDeps = Object.keys(packageJSON.dependencies ?? {});
+
+  // check if any rhachet package is in prod dependencies
+  const rhachetInProdDeps = prodDeps.some((dep) =>
+    rhachetPackagePattern.test(dep),
+  );
+
+  if (rhachetInProdDeps) return; // matches bad practice
+  throw new Error('does not match bad practice');
+};
+
+export const fix: FileFixFunction = (contents) => {
+  if (!contents) return { contents };
+
+  const packageJSON = JSON.parse(contents);
+  const prodDeps = { ...packageJSON.dependencies };
+  const devDeps = { ...packageJSON.devDependencies };
+
+  // find all rhachet packages in prod deps and move them to dev deps
+  for (const dep of Object.keys(prodDeps)) {
+    if (rhachetPackagePattern.test(dep)) {
+      devDeps[dep] = prodDeps[dep];
+      delete prodDeps[dep];
+    }
+  }
+
+  const fixedPackageJSON = {
+    ...packageJSON,
+    dependencies: Object.keys(prodDeps).length > 0 ? prodDeps : undefined,
+    devDependencies: Object.keys(devDeps).length > 0 ? devDeps : undefined,
+  };
+
+  return { contents: JSON.stringify(fixedPackageJSON, null, 2) };
+};

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/review-peer-artifacts/.behavior/<star><star>/.reviews/<star><star>/<star>peer-review<star>.md.declapract.ts

@@ -0,0 +1,16 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+/**
+ * .what = detects committed peer-review artifacts under .behavior/**\/.reviews
+ * .why = peer-review files are noise; far less important than the root behavior
+ *        files, so they should not be tracked in git
+ *
+ * .note = matches the old flat shape, where peer-review files sit directly in
+ *         .reviews with `peer-review` in the filename
+ */
+
+export const check = FileCheckType.EXISTS;
+
+export const fix: FileFixFunction = () => {
+  return { contents: null }; // delete the file
+};

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/review-peer-artifacts/.behavior/<star><star>/.reviews/peer/<star><star>/<star>.md.declapract.ts

@@ -0,0 +1,16 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+/**
+ * .what = detects committed peer-review artifacts under .behavior/**\/.reviews/peer
+ * .why = peer-review files are noise; far less important than the root behavior
+ *        files, so they should not be tracked in git
+ *
+ * .note = matches the new shape, where all peer-review files live under a
+ *         dedicated `peer` directory
+ */
+
+export const check = FileCheckType.EXISTS;
+
+export const fix: FileFixFunction = () => {
+  return { contents: null }; // delete the file
+};

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/bad-practices/review-peer-artifacts/.declapract.readme.md

@@ -0,0 +1,12 @@
+peer review artifacts should not be committed to git
+
+these files live under `.behavior/**/.reviews/` and capture peer-review feedback
+from the behavior build lifecycle. they are noise for the most part — far less
+important than the root behavior files themselves.
+
+two path shapes are removed:
+
+- old (flat): `.behavior/**/.reviews/**/*peer-review*.md`
+- new (peer dir): `.behavior/**/.reviews/peer/**/*.md`
+
+self-reviews and other non-peer artifacts under `.reviews/` are intentionally left alone.

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/.agent/keyrack.yml.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.EXISTS;

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/.declapract.readme.md

@@ -0,0 +1,32 @@
+rhachet boots roles, and role boots write scratch state into `.agent/.cache/`
+
+so this practice declares the gitignore line for that dir — the practice that creates the scratch
+declares its ignore, rather than a neighbor practice a repo may not have taken.
+
+📖 several practices declare this same `.gitignore`. the contract they share — one shared
+algorithm, the ordered tail, what a new declarer owes — is stated once at
+`.agent/repo=.this/role=any/briefs/howto.declare-the-repo-gitignore.md`. read that before you add
+a line here.
+
+## it declares only `.agent/.cache/`, not `.cache/`
+
+`.cache/` is generic tool scratch and belongs to the `git` practice. a practice declares the
+ignore for the dirs it creates.
+
+⚠️ **"rhachet owns it" does not mean "git should drop it".** the `git` practice declares
+`.agent/.cache/` too, and that line stays: `app-react-native-expo` (`src/useCases.yml`) takes
+`git` **without** `rhachet`, so for those repos git's line is the only explicit source of the
+ignore.
+
+## the end-to-end proof lives under the git practice
+
+`src/practices/git/.declapract.integration.test.ts` → `[case2] a repo whose use case has rhachet
+but NOT git`.
+
+that is the scenario which justifies this declaration at all. it clones a demo repo whose use case
+omits `git`, applies **this** practice alone, and asserts the agent cache path is ignored with no
+help from git, that `.cache/` is correctly absent, that the negation is honored by git itself, and
+that a re-apply changes zero bytes.
+
+it sits there because one temp repo must hold both declarations to prove they agree. this pointer
+exists so a reader in `src/practices/rhachet/` can find it.

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/.gitignore.declapract.ts

@@ -0,0 +1,64 @@
+import type { FileCheckFunction, FileFixFunction } from 'declapract';
+import expect from 'expect';
+
+import { defineExpectedGitignoreContents } from '../../../utils/defineExpectedGitignoreContents';
+
+/**
+ * ignores that this practice itself owns
+ *
+ * .why = rhachet boots roles which write scratch state into `.agent/.cache/`. the
+ *        practice that creates the dir declares the ignore for it, so a repo that
+ *        takes `rhachet` is never left with cruft it did not ask for:
+ *        - a worktree teardown is not snagged by untracked scratch
+ *        - a hurried `git add .` cannot sweep a debug file that holds a secret
+ *
+ * .note = `.cache/` is generic tool scratch and belongs to the `git` practice, not
+ *         here. a practice declares the ignore for the dirs IT creates, and no more.
+ *
+ * .note = this list is NOT sorted here, and that is deliberate. `defineExpectedGitignoreContents`
+ *         sorts the union of these lines with the repo's own, so a `.sort()` at this site would
+ *         be a second sort that changes no output -- while it mutates a module-cached array in
+ *         place. `readonly` forbids that mutation outright rather than merely discourages it
+ *         (`rule.prefer.prevent-over-correct`).
+ */
+const ignoresSortable: readonly string[] = ['.agent/.cache/'];
+
+/**
+ * .what = emits the `.gitignore` this practice declares, given the repo's extant one
+ * .why  = the algorithm AND the ordered tail are imported, not declared here, because
+ *         `src/practices/git/best-practice/.gitignore.declapract.ts` declares this same
+ *         repo-root file. two declarers converge only while both emit an identical tail
+ *         by an identical algorithm -- so they share one, and the drift that would break
+ *         convergence cannot be written.
+ * .note = this file declares only `ignoresSortable`, which is the part the two
+ *         practices legitimately DIFFER on: rhachet owns `.agent/.cache/`, git owns
+ *         the generic scratch. the shared part is shared; the owned part is owned.
+ */
+const defineExpectedContents = (contents: string | null): string =>
+  defineExpectedGitignoreContents({ contents, ignoresSortable });
+
+/**
+ * .what = throws when the repo's `.gitignore` does not carry what this practice declares
+ * .why  = `check` is the GATE: declapract runs `fix` for a file only when `check`
+ *         rejects it. so this is what makes an upgrade actually deliver
+ *         `.agent/.cache/` to a repo that lacks it.
+ * .note = best-practice semantics are inverted from what a reader expects -- a THROW
+ *         means the practice is violated, a return means it is followed. see
+ *         `.agent/repo=.this/role=any/briefs/declapract-check-semantics.md`.
+ */
+export const check: FileCheckFunction = (contents) => {
+  expect(contents).toEqual(defineExpectedContents(contents));
+};
+
+/**
+ * .what = unions this practice's declared ignores into the repo's `.gitignore`
+ * .why  = a findsert by construction -- a line already present stays present once,
+ *         and a repo's own custom ignores survive, because the file's extant lines
+ *         are unioned in before the sort.
+ * .note = a fixed point: `fix(fix(x)) === fix(x)`, and `check` passes on its own
+ *         output -- without both, `declapract fix` would rewrite this file forever.
+ *         clamped by `.gitignore.declapract.test.ts` -> `idempotency`.
+ */
+export const fix: FileFixFunction = (contents) => {
+  return { contents: defineExpectedContents(contents) };
+};

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/package.json

@@ -0,0 +1,18 @@
+{
+  "devDependencies": {
+    "rhachet": "@declapract{check.minVersion('1.43.1')}",
+    "rhachet-brains-anthropic": "@declapract{check.minVersion('0.4.1')}",
+    "rhachet-brains-fireworksai": "@declapract{check.minVersion('0.1.3')}",
+    "rhachet-brains-xai": "@declapract{check.minVersion('0.3.3')}",
+    "rhachet-roles-bhrain": "@declapract{check.minVersion('0.29.24')}",
+    "rhachet-roles-bhrowser": "@declapract{check.minVersion('0.1.0')}",
+    "rhachet-roles-bhuild": "@declapract{check.minVersion('0.21.22')}",
+    "rhachet-roles-ehmpathy": "@declapract{check.minVersion('1.38.1')}",
+    "rhachet-roles-ghlitch": "@declapract{check.minVersion('0.2.5')}",
+    "rhachet-roles-rhachet": "@declapract{check.minVersion('0.1.7')}"
+  },
+  "scripts": {
+    "prepare:rhachet": "rhachet init --keys --hooks --roles mechanic behaver driver reviewer librarian ergonomist architect dispatcher learner operator observer deployer playwright enroller",
+    "upgrade:rhachet": "rhachet upgrade"
+  }
+}

package/dist/.test/assets/expo-migration/declarations/practices/rhachet/best-practice/package.json.declapract.ts

@@ -0,0 +1,3 @@
+import { FileCheckType } from 'declapract';
+
+export const check = FileCheckType.CONTAINS;

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/javascript-config-files/.declapract.readme.md

@@ -0,0 +1 @@
+we've migrated to using `.ts` config files for jest config, rather than `.js`

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/javascript-config-files/jest.<star>.js.declapract.ts

@@ -0,0 +1,17 @@
+import { FileCheckType, type FileFixFunction } from 'declapract';
+
+export const check = FileCheckType.EXISTS;
+
+/**
+ * .what = deletes a stale `.js` jest config file
+ * .why  = the go-forward jest config is `.ts` (see .declapract.readme.md). a leftover
+ *         `.js` jest config (e.g. a jsdom `jest.config.js` or a `jest.unit.config.js`)
+ *         is redundant and fights the shipped `.ts` config — the dual-source hazard the
+ *         app-protools-native migration must reconcile. drop the redundant `.js`; the
+ *         best-practice supplies the canonical `.ts` config in the same pass.
+ * .note  = `{ contents: null }` removes the file. idempotent: once gone, the EXISTS
+ *          check no longer detects it, so a re-run is a no-op.
+ */
+export const fix: FileFixFunction = () => {
+  return { contents: null };
+};

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/mocks/.declapract.readme.md

@@ -0,0 +1,8 @@
+should not have any `__mock__` directories
+
+these are hard to track down and are too "magical" and affect _all_ tests (i.e., inter test dependency)
+
+just explicitly mocks manually in each test OR root level in setup env with:
+```ts
+jest.mock("...");
+```

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.js

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/mocks/<star><star>/__mock__/<star>.ts

@@ -0,0 +1,3 @@
+/**
+ * bad practice: file exists
+ */

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.integration.test.ts

@@ -0,0 +1,63 @@
+import fs from 'fs/promises';
+import path from 'node:path';
+
+import { executeApply } from 'declapract';
+import { genTempDir, given, then, useThen, when } from 'test-fns';
+
+/**
+ * .what = integration test for old-acceptance-dir-location bad practice
+ * .why = reproduces bug where files with non-ts extensions are silently dropped
+ */
+describe('old-acceptance-dir-location', () => {
+  given('[case1] accept.blackbox/ with various file types', () => {
+    const tempDir = genTempDir({
+      slug: 'declapract-old-acceptance-dir',
+      clone: './src/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir',
+      symlink: [{ at: 'src', to: 'src' }],
+    });
+
+    when('[t0] before fix', () => {
+      then('accept.blackbox/ contains files', async () => {
+        const rhachetFile = path.join(
+          tempDir,
+          'accept.blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(rhachetFile);
+        expect(stats.isFile()).toBe(true);
+      });
+    });
+
+    when('[t1] declapract fix is applied', () => {
+      useThen('fix is applied', async () => {
+        await executeApply({
+          config: path.join(tempDir, 'declapract.use.yml'),
+          practice: 'tests-any',
+        });
+      });
+
+      then('somefile.ts is moved to blackbox/', async () => {
+        const newPath = path.join(tempDir, 'blackbox/somefile.ts');
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.rhachet/manifest.json is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.rhachet/manifest.json',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+
+      then('.agent/config.yml is moved to blackbox/', async () => {
+        const newPath = path.join(
+          tempDir,
+          'blackbox/.test/assets/.agent/config.yml',
+        );
+        const stats = await fs.stat(newPath).catch(() => null);
+        expect(stats?.isFile()).toBe(true);
+      });
+    });
+  });
+});

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.declapract.readme.md

@@ -0,0 +1,22 @@
+# old-acceptance-dir-location
+
+## .what
+
+detects test files located in `acceptance/` or `accept.blackbox/` directories and migrates them to `blackbox/`.
+
+## .why
+
+the term "blackbox" makes the testing philosophy explicit:
+- blackbox tests interact only through public contracts (APIs, CLIs, SDKs)
+- no access to internal implementation details
+- tests validate behavior from the caller's perspective
+
+the rename from `acceptance/` or `accept.blackbox/` to `blackbox/` clarifies this intent and simplifies the naming.
+
+## .fix
+
+moves all files from `acceptance/` or `accept.blackbox/` to `blackbox/` while preserving the directory structure.
+
+## .note
+
+the `.acceptance.test.ts` file extension is preserved — it communicates the test type while the directory name communicates the testing philosophy.

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.agent/config.yml

@@ -0,0 +1 @@
+key: value

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/.test/assets/.rhachet/manifest.json

@@ -0,0 +1 @@
+{}

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/accept.blackbox/somefile.ts

@@ -0,0 +1 @@
+export const x = 1;

package/dist/.test/assets/expo-migration/declarations/practices/tests-any/bad-practices/old-acceptance-dir-location/.test/assets/demo-repo-with-accept-blackbox-dir/declapract.declare.yml

@@ -0,0 +1,4 @@
+declare:
+  examples: src/examples
+  practices: src/practices
+  use-cases: src/useCases.yml