KodeBack Journal
Recovery notes grounded in shipped evidence.
How we reason about donor authority, source maps, vendor boundaries, protected contracts, semantic recovery, parity, and maintainable handoff.
Temporary Proof Modules Should Not Become Permanent Architecture
How scratch-only verification work can support a change without leaking scaffolding into the deliverable.
The Output Folder Is Part of the Safety Boundary
Why parity reports should not overwrite unrelated work or become part of their own input.
One Source Hash Can Have Several Consumers
Why a set of artifact identities is not a count of rewritten files or module instances.
A Visible Button Is Not Evidence of Gameplay
How explicit behavior witnesses narrow a comparison without proving unobserved effects.
An Offline Cache Miss Should Not Change the Rules
Why package preparation must refuse missing authority instead of silently contacting a registry.
Dry Run Means Planned, Not Externalized
How to read a direct externalization preview without overstating what happened.
Do Not Replace Half a Singleton Family
Why coordinated package identity matters more than a successful individual import rewrite.
A Captured Import Is Not Browser Resolution Authority
Why module instances and import maps remain a separate question from dependency presence.
When a Shared Helper Blocks Externalization
Why a useful refusal should name the callers that keep a helper in place.
The Static Initializer That Must Stay in Order
Why package-looking property assignments cannot be removed on appearance alone.
One Declaration Can Contain Two Owners
Why mixed first-party and vendor declarations need a narrower carve than a whole-statement delete.
Shared State Can Make Two Declarations One Unit
How atomic closure follows writers and callers without merging every shared helper.
The Unicode Bug Hiding in a Source Span
Why Kalu binds bundle edits to UTF-8 byte ranges rather than JavaScript string length.
A Match Inside a Bundle Is Not Ownership of the Bundle
Why containment evidence should not become permission to remove surrounding application code.
Why Reference Bytes Need Their Own Provenance
A dependency comparison is only as meaningful as the package artifact it compares against.
Read the Fingerprint Lanes, Not Just the Headline
Why a completed fingerprint can still contain unavailable or unresolved evidence.
A Library Revision Is Not an Exact Package Patch
How to interpret a useful version clue without turning it into an unjustified install pin.
Why the Candidate You Edit Is Not the Tree We Measure Live
How an owned scratch view makes a parity run easier to interpret.
A Proposed Parity Plan Is Not a Passing Result
Why KodeBack refuses to turn an automatically proposed comparison into qualification.
The CSS Regression a Boot Check May Not See
Why semantic DOM parity must not be sold as complete visual equivalence.
Read a Capture Before You Create a Candidate
Why dependency fingerprinting can be useful without browser execution or workspace mutation.
Controlled Boot Is Not a Deterministic Universe
What KodeBack fixes, what remains native, and why the saved profile matters.
When the Unchanged Candidate Will Not Pass
Why a blocked baseline should stop the comparison rather than start a cycle of speculative edits.
What KodeBack Init Does Not Do
Candidate publication is a useful milestone, but it is not installation, execution, or qualification.
Prepare, Edit, Check: A Smaller Recovery Feedback Loop
How KodeBack separates an unchanged baseline from later candidate edits.
Calibrating Semantic Renames Instead of Trusting Confidence
A model’s confidence is not a rename safety threshold. Reliable automation needs adjudicated examples, independent evidence, risk curves, and a protected-surface veto.
When Client-Side Recoverability Becomes an Architecture Risk
Frontend code is expected to be recoverable. Risk rises when recoverable logic includes secrets, entitlement decisions, privileged host channels, or server-authoritative rules.
Donor, Evidence, Candidate: Three Trust Surfaces in Source Recovery
A recovery workspace becomes safer when deployed bytes, derived evidence, and editable source have different owners and different authority.
Identify Vendor Code Before Rewriting the Bundle
Production JavaScript mixes application logic, third-party libraries, generated wrappers, and bundler runtime. Cleanup should begin only after those ownership boundaries are measured.
Protected Surfaces: The Names a Cleanup Must Not Improve
Routes, storage keys, event names, asset identities, host channels, and serialized fields can look like bad identifiers while acting as external contracts.
Why a Source-Recovery Pipeline Must Be Restartable
Long recovery work survives interruptions only when stages are checkpointed, evidence is freshness-bound, and restart decisions are explicit.
Runtime Smoke Is a Contract, Not a Screenshot
A candidate that starts is not necessarily a candidate that booted correctly. Runtime smoke needs declared routes, readiness, errors, resources, and ownership evidence.
Source Maps Are a Fast Track, Not a Finish Line
Source maps can restore authored files and names, but they do not by themselves recover a reproducible project or prove runtime ownership.