789ea48316e55c05aa8da07a8ff98f329ce0489b
4
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 ed
|
789ea48316 |
conductor(plan): Phase 9 complete (t9_0-t9_7); t9_8 = final checkpoint
Phase 9 patch complete (per Tier 1's spec.md §12): - t9_0 (styleguide re-read): commit |
||
|
ed
|
8f6d044d16 |
conductor(plan): add Phase 9 (Patch) to result_migration_cruft_removal_20260620
Tier 2's Phase 8 completion report claimed '9 wrappers obliterated;
campaign 100% complete.' The audit script and test suite prove this is
FALSE:
scripts/audit_legacy_wrappers.py found 3 remaining wrappers:
src/gui_2.py:227 _detect_refresh_rate_win32
src/gui_2.py:277 _resolve_font_path
src/rag_engine.py:250 _chunk_code
pytest tests/test_baseline_result.py: 7 failed, 24 passed
(the same 7 scaffolding failures as sub-track 5)
Tier 2's 'obliterate' commits total only 2 in the branch:
|
||
|
ed
|
bdd388e877 |
conductor(plan): flesh out cruft removal plan with per-phase detail
The plan was 38 lines (just header + protocol). Now 573 lines with
proper per-phase task structure:
- The Wrapper-Obliteration Pattern (concrete BEFORE/AFTER code;
legacy wrapper DELETED in same commit as caller migration)
- Phase 0: Setup + styleguide re-read (3 tasks)
- Phase 1: Fix the 7 failing tests (5 tasks; commit missing
PHASE1_AUDIT_BASELINE.json + split combined inventory doc)
- Phase 2: Final detailed audit (6 tasks; write audit_legacy_wrappers.py
script + per-wrapper inventory doc with callers + drain targets)
- Phases 3-7: Per-file wrapper removal (one task per wrapper per file;
the OBLITERATE pattern: find caller -> rewrite -> delete wrapper)
- Phase 8: Audit gate + end-of-track report + campaign close-out
(8 tasks; final state: 0 legacy wrappers + 0 audit violations
+ 47/47 tests + 11/11 tiers PASS)
Each phase has:
- Styleguide re-read + ack commit (mandatory)
- Concrete commands with expected output
- Per-file atomic commits (1 wrapper = 1 commit)
- Per-phase invariant test + checkpoint
The OBLITERATE principle is explicit: no pass-throughs; no backward
compat; in-site callers rewritten to use _x_result(...).ok directly.
The dead code dies.
|
||
|
ed
|
6e887122f5 |
conductor(plan): initialize result_migration_cruft_removal_20260620 (Wrapper Obliteration)
Final cleanup track of the 5-sub-track result-migration campaign.
Obliterates every legacy wrapper in src/ — the false-drain pattern
introduced in sub-track 3 Phase 6 Group 6.3 (def _x(): return _x_result(...).data)
which silently swallows the Result errors and defeats the entire purpose
of the Result[T] migration.
Per user directive (2026-06-20): 'I want to obliterate excess code. I'm
trying to prune the codebase of bad programming practices. I can't have
false drain sites just to support a legacy connection when the on-site
call can just be properly rewritten to use the proper path.'
Scope:
- 8+ legacy wrappers in src/ (preliminary; Phase 2 will enumerate exactly)
- 91 _result helpers total (many of which are only called via the legacy
wrapper, meaning errors are silently dropped at every call site)
- 7 failing inventory tests in tests/test_baseline_result.py from sub-track 5
(PHASE1_AUDIT_BASELINE.json was never committed; 3 per-file inventory
docs were collapsed to 1 combined doc; tests reference the 3-file convention)
The 9-Phase Structure:
0. Setup + styleguide re-read
1. Fix the 7 failing tests (test scaffolding repair; no production code)
2. Final detailed audit (full legacy wrapper inventory in
tests/artifacts/PHASE2_WRAPPER_AUDIT.md)
3-7. Per-file wrapper removal (mcp_client, ai_client, rag_engine, then
other src/ files per Phase 2 inventory)
8. Audit gate + end-of-track report + campaign close-out
The migration pattern per wrapper:
BEFORE (legacy wrapper — false drain):
def _x_result(...): -> Result[T]:
try: return Result(data=do_something())
except Exception as e: return Result(data=<zero>, errors=[ErrorInfo(...)])
def _x(...): # ← false drain
result = _x_result(...)
if not result.ok: pass # ERROR DROPPED
return result.data
AFTER (legacy wrapper DELETED; caller rewritten):
def _x_result(...): -> Result[T]: # unchanged
...
# caller is rewritten:
def caller(...):
result = _x_result(...)
if not result.ok:
log_error_to_drain(result.errors[0])
return <caller-specific-fallback>
return result.data
# def _x(...): ← DELETED (no pass-through; no backward compat)
No pass-throughs. No backward compat. The dead code dies.
Per-wrapper atomic commit (1 wrapper = 1 commit).
Files:
- spec.md (Section 0-11; 4 FRs for Phase 1; per-phase migration strategy;
explicit 'no pass-throughs' principle)
- plan.md (anti-sliming protocol; file structure; per-phase task list)
- metadata.json (12 VCs; 3 risks; 1 pre-existing failure (7 failing tests))
- state.toml (9 phases; ~50 tasks; 15 verification entries;
campaign_closeout = true)
Total: 4 files, ~1300 lines added. Closes the result-migration campaign
when SHIPPED (0 legacy wrappers + 0 test failures + 0 audit violations
across all 65 src/ files).
Next: Tier 2 picks up Phase 0 (setup + styleguide re-read) per the
task list in state.toml. The 7 failing tests are fixed in Phase 1.
The full legacy wrapper enumeration is Phase 2. Wrapper removal begins
Phase 3 (mcp_client).
|