rhachet-roles-ehmpathy 1.17.17 → 1.17.18

package/dist/domain.roles/mechanic/briefs/.archive/_mech.compressed.md

@@ -5,8 +5,8 @@
   - inline callbacks may be exempt if anonymous + tightly scoped
   - **example:**
     ```ts
-    export const doWork = async (input, context) => { ... }       // ✅
-    export function legacyFunc(a, b) {}                           // ⛔
+    export const doWork = async (input, context) => { ... }       // 👍
+    export function legacyFunc(a, b) {}                           // 👎
     ```
 
 ---
@@ -18,8 +18,8 @@
   - always destructure `input` as first argument when applicable
   - **example:**
     ```ts
-    const getName = ({ name }) => name;                          // ✅
-    export function getName(name) { return name }                // ⛔
+    const getName = ({ name }) => name;                          // 👍
+    export function getName(name) { return name }                // 👎
     ```
 
 ---

package/dist/domain.roles/mechanic/briefs/.archive/patterns.directional-dependencies.md

@@ -56,7 +56,7 @@ src/
 
 .examples
 
-✅ positive
+👍 positive
 \`\`\`ts
 // contract/endpoints/sendInvoice.ts
 import { generateInvoice } from '@/domain.operations/generateInvoice';
@@ -69,14 +69,14 @@ import { Job } from '@/domain.objects/Job';
 import { LineItem } from '@/domain.objects/LineItem';
 \`\`\`
 
-❌ negative
+👎 negative
 \`\`\`ts
 // domain.objects/Customer.ts
-import { customerDao } from '@/access/daos/customerDao'; // ⛔ illegal upward import
+import { customerDao } from '@/access/daos/customerDao'; // 👎 illegal upward import
 
 // domain.operations/InvoiceOps.ts
-import { runFlow } from '@/contract/commands'; // ⛔ direction violation
+import { runFlow } from '@/contract/commands'; // 👎 direction violation
 
 // access/svcs/sdkWrapper.ts
-import { dispatchFlow } from '@/contract/'; // ⛔ bottom-up reference
+import { dispatchFlow } from '@/contract/'; // 👎 bottom-up reference
 \`\`\`

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.architecture/rule.require.bounded-contexts.md

@@ -43,9 +43,9 @@
     - `routes/submitJob.ts` orchestrates job + invoice via stitch, not via import of both
 
   .negative:
-    - `job.ts` imports `from '../../invoice/utils.ts'` ⛔ reach-in
-    - `invoiceService.ts` directly updates `customer.email` ⛔ cross-context mutation
-    - `customer.ts` imports `JobQuote` and infers state ⛔ ownership violation
+    - `job.ts` imports `from '../../invoice/utils.ts'` 👎 reach-in
+    - `invoiceService.ts` directly updates `customer.email` 👎 cross-context mutation
+    - `customer.ts` imports `JobQuote` and infers state 👎 ownership violation
 
 
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.domain.objects/ref.package.domain-objects.[ref].md

@@ -298,16 +298,16 @@ class SeaTurtle extends DomainEntity<SeaTurtle> implements SeaTurtle {
   public static unique = ['seawaterSecurityNumber'] as const;
 }
 
-// ✅ valid
+// 👍 valid
 const primaryRef: RefByPrimary<typeof SeaTurtle> = { uuid: 'beefbeef...' };
 
-// ❌ invalid - must be a string
+// 👎 invalid - must be a string
 const wrongType: RefByPrimary<typeof SeaTurtle> = { uuid: 8335 };
 
-// ❌ invalid - wrong key
+// 👎 invalid - wrong key
 const wrongKey: RefByPrimary<typeof SeaTurtle> = { guid: 'beefbeef...' };
 
-// ❌ invalid - missing primary key
+// 👎 invalid - missing primary key
 const missing: RefByPrimary<typeof SeaTurtle> = {};
 ```
 
@@ -328,16 +328,16 @@ class SeaTurtle extends DomainEntity<SeaTurtle> implements SeaTurtle {
   public static unique = ['seawaterSecurityNumber'] as const;
 }
 
-// ✅ valid
+// 👍 valid
 const uniqueRef: RefByUnique<typeof SeaTurtle> = { seawaterSecurityNumber: 'ABC-999' };
 
-// ❌ invalid - wrong type
+// 👎 invalid - wrong type
 const wrongType: RefByUnique<typeof SeaTurtle> = { seawaterSecurityNumber: 999 };
 
-// ❌ invalid - wrong key
+// 👎 invalid - wrong key
 const wrongKey: RefByUnique<typeof SeaTurtle> = { saltwaterSecurityNumber: 'ABC-999' };
 
-// ❌ invalid - empty object
+// 👎 invalid - empty object
 const empty: RefByUnique<typeof SeaTurtle> = {};
 ```
 
@@ -359,22 +359,22 @@ class EarthWorm extends DomainEntity<EarthWorm> implements EarthWorm {
   public static unique = ['soilSecurityNumber', 'wormSegmentNumber'] as const;
 }
 
-// ✅ primary
+// 👍 primary
 const byPrimary: Ref<typeof EarthWorm> = { uuid: 'beefbeef...' };
 
-// ✅ unique
+// 👍 unique
 const byUnique: Ref<typeof EarthWorm> = {
   soilSecurityNumber: 'SOIL-001',
   wormSegmentNumber: 'SEG-42',
 };
 
-// ❌ invalid - missed part of unique key
+// 👎 invalid - missed part of unique key
 const incompleteUnique: Ref<typeof EarthWorm> = { soilSecurityNumber: 'SOIL-001' };
 
-// ❌ invalid - not related to either key
+// 👎 invalid - not related to either key
 const wrongKey: Ref<typeof EarthWorm> = { guid: 'beefbeef...' };
 
-// ❌ invalid - empty object
+// 👎 invalid - empty object
 const empty: Ref<typeof EarthWorm> = {};
 ```
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.domain.operations/define.domain-operation-core-variants.md

@@ -48,7 +48,7 @@ when both variants exist in a codebase, the prefix:
 
 #### .examples
 
-**✅ good — leaf operations with proper prefixes**
+**👍 good — leaf operations with proper prefixes**
 ```ts
 // computeInvoiceTotal.ts — leaf, deterministic
 export const computeInvoiceTotal = (input: { lineItems: LineItem[] }) => {
@@ -67,7 +67,7 @@ export const imagineChapterSummary = async (
 };
 ```
 
-**✅ good — composer operation with normal name**
+**👍 good — composer operation with normal name**
 ```ts
 // getInvoiceWithSummary.ts — composes both variants
 export const getInvoiceWithSummary = async (
@@ -81,15 +81,15 @@ export const getInvoiceWithSummary = async (
 };
 ```
 
-**⛔ bad — prefix misleads**
+**👎 bad — prefix misleads**
 ```ts
 // computeResponse.ts — "compute" but actually calls LLM
 export const computeResponse = async (input, context) => {
-  return context.brain.repl.imagine({ ... }); // ⛔ prefix misleads
+  return context.brain.repl.imagine({ ... }); // 👎 prefix misleads
 };
 ```
 
-**⛔ bad — ambiguous leaf name (only when both variants exist)**
+**👎 bad — ambiguous leaf name (only when both variants exist)**
 ```ts
 // generateTotal.ts — unclear if deterministic or probabilistic
 export const generateTotal = (...) => { ... }

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.forbid.io-as-domain-objects.md

@@ -30,12 +30,12 @@ forbid domain objects for procedure inputs and outputs; declare them inline on t
 
 #### .how
 
-##### ✅ required
+##### 👍 required
 - declare input types inline: `(input: { invoice: Invoice; customer: Customer })`
 - declare return types inline: `): Promise<{ success: boolean; invoice: Invoice }>`
 - use domain objects as **properties** within inline types, not as the type itself
 
-##### ❌ forbidden
+##### 👎 forbidden
 - `class SendInvoiceInput extends DomainLiteral<...>`
 - `interface GenerateReportOutput { ... }` in a separate file
 - `type SyncCustomerArgs = { ... }` outside the procedure file
@@ -47,7 +47,7 @@ forbid domain objects for procedure inputs and outputs; declare them inline on t
 
 #### .examples
 
-##### ✅ positive
+##### 👍 positive
 ```ts
 /**
  * .what = sends an invoice to the customer
@@ -74,9 +74,9 @@ export const generateMonthlyReport = async (
 };
 ```
 
-##### ❌ negative
+##### 👎 negative
 ```ts
-// ⛔ input as domain object — SendInvoiceInput is not a domain concept
+// 👎 input as domain object — SendInvoiceInput is not a domain concept
 interface SendInvoiceInput {
   invoice: Invoice;
   customer: Customer;
@@ -88,7 +88,7 @@ export const sendInvoice = async (input: SendInvoiceInput, context: Context) =>
 ```
 
 ```ts
-// ⛔ output as separate type — pollutes type namespace with transient shapes
+// 👎 output as separate type — pollutes type namespace with transient shapes
 type GenerateReportResult = {
   report: Report;
   generatedAt: string;
@@ -98,7 +98,7 @@ export const generateMonthlyReport = async (input: {...}): Promise<GenerateRepor
 ```
 
 ```ts
-// ⛔ args file pattern — fragments the contract across files
+// 👎 args file pattern — fragments the contract across files
 // file: generateReport.args.ts
 export interface GenerateReportArgs { ... }
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.forbid.io-as-interfaces.md

@@ -32,12 +32,12 @@ forbid separate `interface` or `type` declarations for procedure inputs and outp
 
 #### .how
 
-##### ✅ required
+##### 👍 required
 - declare input types inline on the procedure signature
 - declare return types inline on the procedure signature
 - use domain objects as **properties** within inline types when appropriate
 
-##### ❌ forbidden
+##### 👎 forbidden
 - `interface DoThingInput { ... }` declarations
 - `interface DoThingOutput { ... }` declarations
 - `type DoThingArgs = { ... }` declarations
@@ -51,7 +51,7 @@ forbid separate `interface` or `type` declarations for procedure inputs and outp
 
 #### .examples
 
-##### ✅ positive
+##### 👍 positive
 ```ts
 /**
  * .what = syncs customer phone from external provider
@@ -77,15 +77,15 @@ export const calculateInvoiceTotal = (
 };
 ```
 
-##### ❌ negative
+##### 👎 negative
 ```ts
-// ⛔ separate interface for input
+// 👎 separate interface for input
 interface SyncCustomerPhoneInput {
   customerId: string;
   provider: 'whodis' | 'twilio';
 }
 
-// ⛔ separate interface for output
+// 👎 separate interface for output
 interface SyncCustomerPhoneOutput {
   updated: boolean;
   phoneBefore: string | null;
@@ -99,7 +99,7 @@ export const syncCustomerPhone = async (
 ```
 
 ```ts
-// ⛔ type aliases for single-use shapes
+// 👎 type aliases for single-use shapes
 type CalculateTotalArgs = {
   lineItems: LineItem[];
   taxRate: number;
@@ -115,7 +115,7 @@ export const calculateInvoiceTotal = (input: CalculateTotalArgs): CalculateTotal
 ```
 
 ```ts
-// ⛔ file fragmentation pattern
+// 👎 file fragmentation pattern
 // file: syncCustomerPhone.input.ts
 export interface SyncCustomerPhoneInput { ... }
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.arrow-only.md

@@ -37,11 +37,11 @@ const getName = (input) => input.name;
 
 ###### .negative
 ```ts
-function setCustomerPhone({ customer, phone }) {   // ⛔ function keyword
+function setCustomerPhone({ customer, phone }) {   // 👎 function keyword
   return { ...customer, phone };
 }
 
-export function doWork() {                     // ⛔ export with function
+export function doWork() {                     // 👎 export with function
   ...
 }
 ```

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.clear-contracts.md

@@ -22,7 +22,7 @@
 
 .examples:
 
-✅ good
+👍 good
     // domain/procedures/sendInvoice.ts
 
     /**
@@ -39,7 +39,7 @@
       // ...
     };
 
-❌ bad
+👎 bad
     // logic/sendInvoice.ts
 
     export const sendInvoice = async (invoice, customer) => {

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.dependency-injection.md.pt1.md

@@ -19,7 +19,7 @@ via dependencies that are **explicit, swappable, and controlled from the outside
 for example, instead of a function that reaches for its own dependencies:
 
 ```ts
-// ❌ tightly coupled and side-effect prone
+// 👎 tightly coupled and side-effect prone
 import { log } from '@/utils/logger';
 import { getDatabaseConnection } from '@/utils/database';
 
@@ -33,7 +33,7 @@ export const upsert = async ({ cost }: { cost: JobLeadCost }) => {
 you inject those dependencies via the standard `(input, context)` pattern:
 
 ```ts
-// ✅ dependency injection via context
+// 👍 dependency injection via context
 export const upsert = async (
   { cost }: { cost: JobLeadCost },
   context: { dbConnection: DatabaseConnection, log: LogMethods }, // note how the .context pattern cleanly separates inputs from dependencies

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.hook-wrapper-pattern.md

@@ -24,7 +24,7 @@ the alternative — inline wrapping at the function declaration — causes the e
 
 #### .examples
 
-##### ✅ good — wrapper pattern
+##### 👍 good — wrapper pattern
 
 ```ts
 /**
@@ -43,7 +43,7 @@ const _sendInvoice = async (
 export const sendInvoice = withLogTrail(_sendInvoice);
 ```
 
-##### ✅ good — multiple hooks composed
+##### 👍 good — multiple hooks composed
 
 ```ts
 const _processPayment = async (
@@ -59,10 +59,10 @@ export const processPayment = withLogTrail(
 );
 ```
 
-##### ⛔ bad — inline decoration
+##### 👎 bad — inline decoration
 
 ```ts
-// ⛔ adding/removing the wrapper shifts the entire function body
+// 👎 adding/removing the wrapper shifts the entire function body
 export const sendInvoice = withLogTrail(async (
   input: { invoice: Invoice },
   context: { log: LogMethods },

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.input-context-pattern.md.pt1.md

@@ -18,7 +18,7 @@ enforce hard requirement that all procedure args to follow the canonical pattern
 
 #### .how
 
-##### ✅ required
+##### 👍 required
 - every function must accept exactly:
   - one `input` arg — a destructurable object
   - optional second `context` arg — also a destructurable object
@@ -28,7 +28,7 @@ enforce hard requirement that all procedure args to follow the canonical pattern
 - `input` does **not** need to be destructured at the function boundary; shape like `(input: { ... })` is fine
 - `function` keyword is forbidden unless to implement class methods (see `.tactic:funcs:arrow-only`)
 
-##### ❌ forbidden
+##### 👎 forbidden
 - more than 2 positional args
 - non-destructurable inputs
 - context blended into input
@@ -39,7 +39,7 @@ enforce hard requirement that all procedure args to follow the canonical pattern
 
 ### .examples
 
-##### ✅ positive
+##### 👍 positive
 ```ts
 // standard function
 export const genRoute = async (input: { slug: string }, context?: { traceId?: string }) => { ... }
@@ -51,11 +51,11 @@ const updateUser = ({ userId }: { userId: string }, context: { userDao: UserDao
 expect(hasChanges({ before, after })).toBe(true);
 ```ts
 
-##### ❌ negative
+##### 👎 negative
 ```ts
-export function doThing(a, b, c) {}              // ⛔ positional args & function keyword
+export function doThing(a, b, c) {}              // 👎 positional args & function keyword
 
-handleRequest(input, options, env)               // ⛔ more than two args
+handleRequest(input, options, env)               // 👎 more than two args
 
-export const getTotal = (invoice) => ...         // ⛔ input not typed
+export const getTotal = (invoice) => ...         // 👎 input not typed
 ```

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.input-context-pattern.md.pt2.md

@@ -38,7 +38,7 @@ this pattern maximizes **maintainability** and **readability** by:
 
 ---
 
-## ✅ example
+## 👍 example
 
 \`\`\`ts
 export const sendEmail = (
@@ -52,12 +52,12 @@ export const sendEmail = (
 
 ---
 
-## ❌ anti-pattern
+## 👎 anti-pattern
 
 \`\`\`ts
-// ❌ loses "input" provenance
+// 👎 loses "input" provenance
 export const sendEmail = ({ to, subject, body }: { to: string; subject: string; body: string }) => {};
 
-// ❌ type drift — must look up the type definition elsewhere for basic usage
+// 👎 type drift — must look up the type definition elsewhere for basic usage
 export const sendEmail = (input: EmailInput) => {};
 \`\`\`

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.procedures/rule.require.single-responsibility.md

@@ -10,13 +10,13 @@ enforce that every code file and procedure has a singular, clearly-defined respo
 
 #### .rules
 
-✅ required
+👍 required
 - every file must export **exactly one** named procedure
 - filename must match the exported procedure
-- all logic in the file must directly support the procedure’s **domain intent**
+- all logic in the file must directly support the procedure's **domain intent**
 - runtime typechecks are only allowed **if** the file's sole purpose is validation
 
-❌ forbidden
+👎 forbidden
 - more than one exported procedure per file
 - co-located validation, parse, or orchestration logic alongside domain logic
 - runtime type assertions or guards inside general-purpose logic
@@ -26,7 +26,7 @@ enforce that every code file and procedure has a singular, clearly-defined respo
 
 #### .examples
 
-**✅ good**
+**👍 good**
 ```ts
 // getCustomerInvoices.ts
 /**
@@ -40,25 +40,25 @@ export const getCustomerInvoices = ({ customerId }: { customerId: string }) => {
 
 
 
-**⛔ bad**
+**👎 bad**
 ```ts
 // customerUtils.ts
 // utility file that contains many things
 
 export const getCustomerInvoices = (...) => { ... }
 
-export const validateCustomer = (...) => { ... }  // ❌ multiple responsibilities
+export const validateCustomer = (...) => { ... }  // 👎 multiple responsibilities
 
-// random comment about edge cases — ❌ unrelated noise
+// random comment about edge cases — 👎 unrelated noise
 
 ```
 
 
-**⛔ bad**
+**👎 bad**
 ```ts
 // getCustomerInvoices.ts
 export const getCustomerInvoices = ({ customerId }: { customerId: string }) => {
-  if (typeof customerId !== 'string')  // ❌ redundant runtime check
+  if (typeof customerId !== 'string')  // 👎 redundant runtime check
     throw new Error('bad id');
 
   return invoiceDao.findMany({ customerId });

package/dist/domain.roles/mechanic/briefs/practices/code.prod/evolvable.repo.structure/rule.require.directional-deps.md

@@ -56,7 +56,7 @@ src/
 
 .examples
 
-✅ positive
+👍 positive
 \`\`\`ts
 // contract/endpoints/sendInvoice.ts
 import { generateInvoice } from '@/domain.operations/generateInvoice';
@@ -69,14 +69,14 @@ import { Job } from '@/domain.objects/Job';
 import { LineItem } from '@/domain.objects/LineItem';
 \`\`\`
 
-❌ negative
+👎 negative
 \`\`\`ts
 // domain.objects/Customer.ts
-import { customerDao } from '@/access/daos/customerDao'; // ⛔ illegal upward import
+import { customerDao } from '@/access/daos/customerDao'; // 👎 illegal upward import
 
 // domain.operations/InvoiceOps.ts
-import { runFlow } from '@/contract/commands'; // ⛔ direction violation
+import { runFlow } from '@/contract/commands'; // 👎 direction violation
 
 // access/svcs/sdkWrapper.ts
-import { dispatchFlow } from '@/contract/'; // ⛔ bottom-up reference
+import { dispatchFlow } from '@/contract/'; // 👎 bottom-up reference
 \`\`\`

package/dist/domain.roles/mechanic/briefs/practices/code.prod/pitofsuccess.procedures/rule.require.idempotent-procedures.md

@@ -54,10 +54,10 @@
 
   .negative:
     ```ts
-    await sendEmail(input); // ⛔ no check for previous send
+    await sendEmail(input); // 👎 no check for previous send
     ```
 
     ```ts
-    const saved = await insertLog({ ... }) // ⛔ may insert duplicate on retry
+    const saved = await insertLog({ ... }) // 👎 may insert duplicate on retry
     ```
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/pitofsuccess.procedures/rule.require.immutable-vars.md

@@ -40,9 +40,9 @@
 
   .negative:
     - `let count = 0; count++`
-    - `input.customer.name = 'bob'` // ⛔ input mutation
-    - `config.debug = false` // ⛔ shared singleton mutation
-    - `arr.push(1)` // ⛔ in-place array mutation
+    - `input.customer.name = 'bob'` // 👎 input mutation
+    - `config.debug = false` // 👎 shared singleton mutation
+    - `arr.push(1)` // 👎 in-place array mutation
 
 .links:
   - see also: `arch:immutable-core`, `args:input-context`, `domain-objects.withImmute`

package/dist/domain.roles/mechanic/briefs/practices/code.prod/pitofsuccess.typedefs/define.bivariance-for-generics.[lesson].md

@@ -41,7 +41,7 @@ const specificDao: DeclastructDao<typeof MyResource> = { ... };
 // generic dao shape where RefByPrimary<any> resolves to {}
 type GenericDao = DeclastructDao<any>;
 
-// ❌ fails: {uuid: string} is not assignable to {}
+// 👎 fails: {uuid: string} is not assignable to {}
 const generic: GenericDao = specificDao;
 ```
 
@@ -59,7 +59,7 @@ interface DeclastructDao<TResourceClass> {
   };
 }
 
-// ✅ works: bivariance allows assignment in either direction
+// 👍 works: bivariance allows assignment in either direction
 const generic: GenericDao = specificDao;
 ```
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/pitofsuccess.typedefs/rule.forbid.as-cast.md

@@ -51,13 +51,13 @@
 
   .negative:
     ```ts
-    // ⛔ undocumented cast
+    // 👎 undocumented cast
     const user = data as User;
 
-    // ⛔ cast to silence error
+    // 👎 cast to silence error
     const result = badFunction() as ExpectedType;
 
-    // ⛔ any-cast escape hatch
+    // 👎 any-cast escape hatch
     const x = (y as any) as SomeType;
     ```
 

package/dist/domain.roles/mechanic/briefs/practices/code.prod/readable.comments/rule.require.what-why-headers.md

@@ -16,11 +16,11 @@ require oneliner summaries of .what and why comments to precede every code parag
 
 comments are a hard requirement — they must follow precise structure and length:
 
-✅ required
+👍 required
 - /** .what, .why */ block above all named procedures
 - // one-liner before every logical paragraph of code
 
-❌ forbidden
+👎 forbidden
 - absent .what or .why above a procedure
 - multiline // paragraph comments
 - vague, redundant, or “code-shaped” comments
@@ -79,14 +79,14 @@ export const proposeCode = async ({ threads }) => {
 
 forbidden, negative examples
 ```ts
-// absent .what/.why above export      ⛔ blocker
+// absent .what/.why above export      👎 blocker
 export const doStuff = () => { ... }
 
-// vague comment                        ⛔ no intent
+// vague comment                        👎 no intent
 // run flow
 const r = run();
 
-// multiline paragraph comment          ⛔ must extract into procedure
+// multiline paragraph comment          👎 must extract into procedure
 // handle logic for retries because retries are complicated
 // and they sometimes need to be skipped on failure
 const result = retry(input);

package/dist/domain.roles/mechanic/briefs/practices/code.prod/readable.comments/rule.require.what-why-headers.v1.md

@@ -48,7 +48,7 @@ const invoice = await getInvoiceById(invoiceId);
 
 #### .examples
 
-##### ✅ positive
+##### 👍 positive
 
 ```ts
 /**
@@ -64,13 +64,13 @@ export const proposeCode = async ({ threads }) => {
 };
 ```
 
-##### ❌ negative
+##### 👎 negative
 
 ```ts
-// run flow  ⛔ unclear
+// run flow  👎 unclear
 const r = await run();
 
-return r.artifact; // ⛔ what is this? why return this?
+return r.artifact; // 👎 what is this? why return this?
 
 // very long comment that describes why this block exists
 // and what it does and why it's written in this particular way

package/dist/domain.roles/mechanic/briefs/practices/code.test/frames.behavior/howto.write-bdd.[lesson].md

@@ -57,7 +57,7 @@ Instead of `let` + `beforeAll` + `afterAll`:
 
 e.g.,
 ```typescript
-// ❌ Don't do this
+// 👎 Don't do this
 let dbConnection: DatabaseConnection;
 beforeAll(async () => {
   dbConnection = await getDatabaseConnection();
@@ -66,7 +66,7 @@ afterAll(async () => {
   await dbConnection.end();
 });
 
-// ✅ Do this
+// 👍 Do this
 const dbConnection = useBeforeAll(() => getDatabaseConnection());
 afterAll(async () => dbConnection.end());
 ```
@@ -102,7 +102,7 @@ given('[case2] second scenario', () => {
 Each `then` block should test a single behavioral assertion. This makes test failures more precise and test names more descriptive:
 
 ```typescript
-// ❌ Don't do this - multiple assertions in one then
+// 👎 Don't do this - multiple assertions in one then
 when('[t0] command executed in PLAN mode', () => {
   then('decision is UPDATE and doer remains unchanged', async () => {
     const result = await command({ mode: 'PLAN' });
@@ -114,7 +114,7 @@ when('[t0] command executed in PLAN mode', () => {
   });
 });
 
-// ✅ Do this - separate then blocks for each behavioral assertion
+// 👍 Do this - separate then blocks for each behavioral assertion
 when('[t0] command executed in PLAN mode', () => {
   then('decision is "UPDATE"', async () => {
     const result = await command({ mode: 'PLAN' });

package/dist/domain.roles/mechanic/briefs/practices/code.test/frames.behavior/howto.write-bdd.[lesson].pt2.md

@@ -74,12 +74,12 @@ given('[case1] prose-author example repo', () => {
 don't split related scenarios across multiple `given` blocks:
 
 ```ts
-// ❌ bad - fragmented
+// 👎 bad - fragmented
 given('[case8] prose-author rule enumeration', () => { ... });
 given('[case9] prose-author chapter enumeration', () => { ... });
 given('[case10] prose-author review works', () => { ... });
 
-// ✅ good - consolidated
+// 👍 good - consolidated
 given('[case8] prose-author example repo', () => {
   when('[t0] before any changes', () => {
     then('rules glob matches', ...);
@@ -93,24 +93,24 @@ given('[case8] prose-author example repo', () => {
 ### when describes state/time, not action
 
 ```ts
-// ❌ bad - describes action
+// 👎 bad - describes action
 when('[t0] assets are checked', () => { ... });
 
-// ✅ good - describes state/time
+// 👍 good - describes state/time
 when('[t0] before any changes', () => { ... });
 ```
 
 ### use afterEach for cleanup
 
 ```ts
-// ❌ bad - inline cleanup
+// 👎 bad - inline cleanup
 then('creates output file', async () => {
   const result = await doThing();
   await fs.rm(outputPath); // cleanup inside then
   expect(result).toBeDefined();
 });
 
-// ✅ good - afterEach cleanup
+// 👍 good - afterEach cleanup
 when('[t1] operation runs', () => {
   const outputPath = path.join(os.tmpdir(), 'output.md');
   afterEach(async () => fs.rm(outputPath, { force: true }));
@@ -125,13 +125,13 @@ when('[t1] operation runs', () => {
 ### preconditions shouldn't expect errors
 
 ```ts
-// ❌ bad - precondition expects error then checks it's not a validation error
+// 👎 bad - precondition expects error then checks it's not a validation error
 then('does not throw validation errors', async () => {
   const error = await getError(doThing());
   expect(error.message).not.toContain('validation');
 });
 
-// ✅ good - precondition checks assets directly
+// 👍 good - precondition checks assets directly
 then('rules glob matches 2 files', async () => {
   const files = await enumFiles({ glob: 'rules/*.md' });
   expect(files).toHaveLength(2);

package/dist/domain.roles/mechanic/briefs/practices/code.test/frames.behavior/rule.require.given-when-then.md

@@ -56,7 +56,7 @@ given('a mechanic with ask, claim, and coderefs', () => {
 ```
 
 ```ts
-when('executed', async () => {        // ⛔ async not allowed in when()
+when('executed', async () => {        // 👎 async not allowed in when()
   const result = await doSomething();
 });
 ```

package/dist/domain.roles/mechanic/briefs/practices/lang.terms/rule.forbid.gerunds.md

@@ -40,7 +40,7 @@ gerund usage = **BLOCKER**
 
 #### .alternatives
 
-| ⛔ gerund | ✅ alternative | .why |
+| 👎 gerund | 👍 alternative | .why |
 |-----------|----------------|------|
 | `existing` | `found`, `current`, `prior` | state, not action |
 | `processing` | `process`, `processor`, `processed` | verb, agent, or result |
@@ -56,7 +56,7 @@ gerund usage = **BLOCKER**
 
 #### .examples
 
-**⛔ bad**
+**👎 bad**
 ```ts
 const existingUser = await findUser();     // gerund
 const processingQueue = [];                 // gerund
@@ -64,7 +64,7 @@ const handlingErrors = true;                // gerund
 // we are currently loading the data        // gerund in comment
 ```
 
-**✅ good**
+**👍 good**
 ```ts
 const userFound = await findUser();         // past participle = result
 const processQueue = [];                    // noun

package/dist/domain.roles/mechanic/briefs/practices/lang.terms/rule.require.order.noun_adj.md.pt2.md

@@ -19,7 +19,7 @@ always use `[noun][state/adjective]` order for variable and property names
 #### .categories
 
 ##### temporal qualifiers
-| ⛔ bad | ✅ good |
+| 👎 bad | 👍 good |
 |--------|---------|
 | `previousValue` | `valuePrevious` |
 | `currentOwner` | `ownerCurrent` |
@@ -28,7 +28,7 @@ always use `[noun][state/adjective]` order for variable and property names
 | `afterState` | `stateAfter` |
 
 ##### state qualifiers (past participles)
-| ⛔ bad | ✅ good |
+| 👎 bad | 👍 good |
 |--------|---------|
 | `existingUser` | `userFound` |
 | `foundRecord` | `recordFound` |
@@ -38,7 +38,7 @@ always use `[noun][state/adjective]` order for variable and property names
 | `matchingResult` | `resultMatched` |
 
 ##### descriptive qualifiers
-| ⛔ bad | ✅ good |
+| 👎 bad | 👍 good |
 |--------|---------|
 | `validInput` | `inputValid` |
 | `emptyList` | `listEmpty` |

package/dist/domain.roles/mechanic/briefs/practices/lang.terms/rule.require.treestruct.md

@@ -41,8 +41,8 @@
       - `invoice`                     // base noun with implicit sense
 
     .negative:
-      - `stepImagineGenFromTemplate`  // ⛔ wrong order — verb must come first
-      - `customerSet`                 // ⛔ vague mechanism — better as `setCustomer` or `setCustomerPhone`
-      - `FoundContent`                // ⛔ reversed word order and PascalCase — should be `contentFound`
-      - `submitQuoteJob`              // ⛔ noun hierarchy flipped — should be `submitJobQuote`
-      - `update()`                    // ⛔ unscoped verb — must include noun domain (e.g., `updateInvoice`)
+      - `stepImagineGenFromTemplate`  // 👎 wrong order — verb must come first
+      - `customerSet`                 // 👎 vague mechanism — better as `setCustomer` or `setCustomerPhone`
+      - `FoundContent`                // 👎 reversed word order and PascalCase — should be `contentFound`
+      - `submitQuoteJob`              // 👎 noun hierarchy flipped — should be `submitJobQuote`
+      - `update()`                    // 👎 unscoped verb — must include noun domain (e.g., `updateInvoice`)

package/dist/domain.roles/mechanic/briefs/practices/lang.tones/rule.prefer.lowercase.md

@@ -29,8 +29,8 @@
       - `// pass into StitchStepImagine to generate`
       - `// openai prompt requires flattened string`
     .negative:
-      - `// Returns a new invoice`       // ⛔ capitalized sentence start
-      - `// This is handled in GitRepo`  // ⛔ capitalized sentence + verb
-      - `// Submit the job for approval` // ⛔ capitalized imperative
-      - `// Customer must exist first`   // ⛔ capitalized domain noun
-      - `// GitHub Repository`           // ⛔ capitalized generic noun
+      - `// Returns a new invoice`       // 👎 capitalized sentence start
+      - `// This is handled in GitRepo`  // 👎 capitalized sentence + verb
+      - `// Submit the job for approval` // 👎 capitalized imperative
+      - `// Customer must exist first`   // 👎 capitalized domain noun
+      - `// GitHub Repository`           // 👎 capitalized generic noun

package/dist/domain.roles/mechanic/briefs/practices/lang.tones/rule.require.term-human.md

@@ -19,14 +19,14 @@ the mechanic always refers to the person they work with as "the human", never "t
 
 ## .examples
 
-### ✅ good
+### 👍 good
 
 - "the human asked for..."
 - "waiting for the human to confirm"
 - "the human's request"
 - "let me check with the human"
 
-### ⛔ bad
+### 👎 bad
 
 - "the user asked for..."
 - "waiting for the user to confirm"

package/package.json

@@ -2,7 +2,7 @@
   "name": "rhachet-roles-ehmpathy",
   "author": "ehmpathy",
   "description": "empathetic software construction roles and skills, via rhachet",
-  "version": "1.17.17",
+  "version": "1.17.18",
   "repository": "ehmpathy/rhachet-roles-ehmpathy",
   "homepage": "https://github.com/ehmpathy/rhachet-roles-ehmpathy",
   "keywords": [
@@ -89,9 +89,9 @@
     "esbuild-register": "3.6.0",
     "husky": "8.0.3",
     "jest": "30.2.0",
-    "rhachet": "1.20.7",
+    "rhachet": "1.21.5",
     "rhachet-roles-bhrain": "0.5.9",
-    "rhachet-roles-bhuild": "0.5.6",
+    "rhachet-roles-bhuild": "0.6.4",
     "rhachet-roles-ehmpathy": "link:.",
     "test-fns": "1.6.0",
     "tsc-alias": "1.8.10",