Fix boolean naming across codebase
Scan, plan, and refactor all boolean naming violations across the codebase until 100% green without stopping.
Prompt
/goal Autonomously scan, plan, refactor, and fix all boolean naming, double negatives, mixed polarity, single-letter boolean parameters (v bool, b bool), bare verb/noun identifiers (stop bool -> isStopped bool, stopOnFail -> isStopOnFail), awkward isExists identifiers (isExists -> isDefined), compound negative chains (!a || !b || c -> discrete checks), and complex condition violations across the codebase, modifying source files directly to enforce affirmative prefixes (is and has only (can, should, was, etc. are banned)), implicit evaluation (no == true), positive framing (no !isSuccess), and discrete condition decomposition until 100% green without stopping
claude-code
Source: alimtvnetwork ↗graded C · 58/100 — how grades work (Safety Score v2) →
Similar loops
All refactoring loops →C
/goalRefactoringhigh risknew
Wrap all Go error returns in Result types
Scan the codebase for all multi-value error tuples, centralize domain structs into types.go, and replace with strongly-typed Result wrappers until all functions return single objects with nil-safe pointer receivers.
/goal Autonomously scan, discover, plan, refactor, and verify all Go functions returning multi-value error tuples (such as (map[K]V, error), ([]T, error), or (T, error)), eliminating raw standard library error returns, centralizing all domain payload structs and Result type aliases into types.go within each package as single reusable types everywhere rather than scattering inline structs or raw generic Result declarations across implementation files, replacing multi-value returns with strongly-typed result wrappers (ResultMap[K, V], ResultSlice[T], Result[T]) and structured *appfault.AppError returns, guaranteeing a single return object, pointer-attached null safety (*Result[T], *ResultSlice[T], *ResultMap[K, V]) with methods attached to pointer receivers ((r *Result[T]), (rs *ResultSlice[T]), (rm *ResultMap[K, V])) that verify if r == nil before dereferencing any fields or checking errors, standardized outer-layer inspection predicates (IsSuccess, IsFailure, HasError, IsEmptyError, IsEmpty, HasRecord, IsDefined, IsCountOtherThan, Data, Items, AppError, Fault, Get, Has, Count), eliminating dual-handling, and replacing verbose if err != nil || len(...) != N or IsFailure() || Count() != N conditions with fluent if res.IsCountOtherThan(N) across the entire codebase until 100% green without stopping
C
/goalRefactoringmedium risk
Convert JavaScript to strict TypeScript
Convert all src/ JS files to TypeScript with strict annotations until npm test passes cleanly.
/goal "Convert all JavaScript files in src/ to TypeScript, add strict type annotations, and ensure npm test passes with zero errors"
C
/goalRefactoringmedium risknew
Split utils into focused modules
Refactor src/utils.js into focused modules under 200 lines each, keeping all exports and signatures intact, until npm run build and npm test both pass with matching test counts.
/goal src/utils.js is split into focused modules each under 200 lines with all imports updated, proven in the transcript by npm run build and npm test both exiting 0 with the same passing-test count as before. Do not change any exported function signature. Stop after 25 turns and report what remains