ZacharyZhang-NY
e74dafcd36
Three independently ugly bugs that all fed the same log flood:
* Electron's `WebFrameMain.send` writes every "Render frame was disposed"
to stderr via `console.error`. When the worker fans a second
agent-event past a reloading renderer, we produced thousands of
identical lines and stalled the main loop on stderr I/O. Added a
`mainFrame.detached` guard so the send is short-circuited before
Electron's own catch block fires, and installed a targeted filter in
`suppress-warnings.ts` (now actually imported from the entry point)
so the specific `console.error("Error sending from webFrameMain:"…)`
noise never reaches the terminal. Any other payload still surfaces.
* `dispatchAgentMessage` accepted the human-reader sentinel as a wake
target when an agent replied to `__board__` — `wakeAgentIfPossible`
then called `db.getAgent("__board__")`, threw, and the dispatcher
kept repeating on every send. Strip `HUMAN_SENDER_ID` at
`resolveMessageWakeTargets`, and keep a defense-in-depth guard in the
heartbeat so a stray caller (future automation fan-out) cannot
reintroduce the crash.
* Pi's skills loader rejects any SKILL.md whose frontmatter `name`
diverges from its parent directory. The four bundled `my-writing-style`
copies declared `name: writing-style-skill`, so every install emitted
a warning and dropped the skill. They also lived as orphan gitlinks
(mode 160000 without .gitmodules), and the global `*.md` gitignore
hid every other SKILL.md from version control. Fixed the frontmatter
to match the dir, converted the dangling submodules to plain trees,
and allowlisted `builtin-skills/**/*.md` so a fresh clone carries the
catalogue instead of silently losing it.
2.3 KiB
2.3 KiB
title, impact, impactDescription, tags
| title | impact | impactDescription | tags |
|---|---|---|---|
| Eliminate Cyclic Dependencies Between Components | CRITICAL | prevents ripple effects, enables independent deployment | dep, cycles, acyclic, components |
Eliminate Cyclic Dependencies Between Components
The dependency graph must be a Directed Acyclic Graph (DAG). Cycles create ripple effects where changes propagate unpredictably through the system.
Incorrect (cyclic dependency):
// modules/orders/OrderService.ts
import { CustomerService } from '../customers/CustomerService'
export class OrderService {
constructor(private customers: CustomerService) {}
async createOrder(customerId: string) {
const customer = await this.customers.findById(customerId)
// ...
}
}
// modules/customers/CustomerService.ts
import { OrderService } from '../orders/OrderService' // Cycle!
export class CustomerService {
constructor(private orders: OrderService) {}
async getCustomerWithOrders(customerId: string) {
const orders = await this.orders.findByCustomer(customerId)
// ...
}
}
// Neither module can be deployed or tested independently
Correct (break cycle with dependency inversion):
// modules/orders/ports/CustomerProvider.ts
export interface CustomerProvider {
findById(id: string): Promise<Customer>
}
// modules/orders/OrderService.ts
import { CustomerProvider } from './ports/CustomerProvider'
export class OrderService {
constructor(private customers: CustomerProvider) {}
async createOrder(customerId: string) {
const customer = await this.customers.findById(customerId)
// ...
}
}
// modules/customers/CustomerService.ts
// No import from orders module
export class CustomerService implements CustomerProvider {
// Implements the interface defined in orders module
}
// modules/customers/adapters/OrderAdapter.ts
import { OrderService } from '../../orders/OrderService'
export class CustomerOrderAdapter {
constructor(private orders: OrderService) {}
async getOrdersForCustomer(customerId: string) {
return this.orders.findByCustomer(customerId)
}
}
Alternative (extract shared abstraction):
Create a new component that both depend on, breaking the cycle into a DAG.
Reference: Clean Architecture - Acyclic Dependencies Principle