fix(shared): stop reporting "not a worktree" when .git cannot be read - #4603

💭 I'm examining the diff in the devHome.ts file to see how it aligns with Effect service conventions. The changes include importing PlatformError, adding an isAbsent predicate that checks for NotFound errors, updating return types to include PlatformError, and using Effect.catchIf to handle specific error cases. Looking at the convention guidance, I'm considering whether catchIf with the isAbsent predicate is appropriate here. The predicate inspects error.reason._tag === "NotFound", which is a nested field within a SystemError rather than the top-level _tag of the PlatformError union itself. Since catchTags works on the top-level discriminant and we're actually distinguishing by a nested reason field, catchIf seems like the right choice here—it's inspecting a genuinely structural aspect of the underlying platform error rather than just recovering a known tagged variant. Now I should review the full file to check for any other convention violations and verify the changes are clean and idiomatic. I'm checking whether the code follows the conventions for error handling. The catchIf function with isAbsent is inspecting the underlying platform error's structural reason to detect "NotFound" errors, which aligns with the guideline that catchIf is appropriate for genuinely structural predicates like platform error codes. So reason is actually a string literal union like "NotFound" or "PermissionDenied", not an object with a _tag property. But the code and tests both reference error.reason._tag, which would be undefined if reason were just a string. This suggests either the Effect version being used has a different structure where reason is an object, or there's something I'm misunderstanding about how PlatformError is defined in this codebase. I'm realizing this is more of a correctness issue than a service convention violation, but the check is specifically focused on Effect service conventions. Let me evaluate the relevant conventions: the guidance against using catchIf with schema predicates to recover known _tag variants suggests using catchTags instead, though catchIf can be appropriate for genuinely structural predicates. I should stick to reviewing only the conventions that are actually in scope for this pull request rather than diving into implementation details like the exact shape of PlatformError. Let me check how other parts of the codebase handle similar error inspection patterns to see if there's a relevant convention I'm missing. I'm looking at how other parts of the codebase check the reason field to figure out whether it's accessed as .reason._tag or just .reason. The pattern of checking error.reason._tag === "NotFound" is consistent throughout the codebase, and in this version of effect, the reason property is a tagged object, so the implementation aligns with established conventions. The code is clean and idiomatic, using catchIf to inspect the platform error's reason tag, which the codebase explicitly supports. I'm realizing there's a tension between the customer's instruction to output exactly "All clear" on one line and the system requirement to respond with JSON matching the schema. The JSON is the actual delivery mechanism, so I'll structure the response to satisfy both: setting the state to success, the title to indicate everything checks out, the summary to "All clear", and leaving details empty.