fix: detect our own hooks by ownership instead of "file would change"

Sources/OpenIslandApp/HookInstallationCoordinator.swift

@@ -472,9 +472,17 @@ final class HookInstallationCoordinator {
             guard let self else { return }
 
             let binaryURL = self.hooksBinaryURL
+            let expectsClaude = self.expectsInstalledHooks(.claudeCode)
+            let expectsCodex = self.expectsInstalledHooks(.codex)
             let (claudeReport, codexReport, openCodeReport) = await Task.detached(priority: .utility) {
-                let claude = HookHealthCheck.checkClaude(hooksBinaryURL: binaryURL)
-                let codex = HookHealthCheck.checkCodex(hooksBinaryURL: binaryURL)
+                let claude = HookHealthCheck.checkClaude(
+                    hooksBinaryURL: binaryURL,
+                    expectsInstalledHooks: expectsClaude
+                )
+                let codex = HookHealthCheck.checkCodex(
+                    hooksBinaryURL: binaryURL,
+                    expectsInstalledHooks: expectsCodex
+                )
                 let openCode = HookHealthCheck.checkOpenCode()
                 return (claude, codex, openCode)
             }.value
@@ -500,9 +508,17 @@ final class HookInstallationCoordinator {
 
         // Re-run health checks first
         let binaryURL = hooksBinaryURL
+        let expectsClaude = expectsInstalledHooks(.claudeCode)
+        let expectsCodex = expectsInstalledHooks(.codex)
         let (claudeReport, codexReport, openCodeReport) = await Task.detached(priority: .utility) {
-            let claude = HookHealthCheck.checkClaude(hooksBinaryURL: binaryURL)
-            let codex = HookHealthCheck.checkCodex(hooksBinaryURL: binaryURL)
+            let claude = HookHealthCheck.checkClaude(
+                hooksBinaryURL: binaryURL,
+                expectsInstalledHooks: expectsClaude
+            )
+            let codex = HookHealthCheck.checkCodex(
+                hooksBinaryURL: binaryURL,
+                expectsInstalledHooks: expectsCodex
+            )
             let openCode = HookHealthCheck.checkOpenCode()
             return (claude, codex, openCode)
         }.value
@@ -536,8 +552,14 @@ final class HookInstallationCoordinator {
         if repaired {
             try? await Task.sleep(for: .milliseconds(500))
             let (updatedClaude, updatedCodex, updatedOpenCode) = await Task.detached(priority: .utility) {
-                let claude = HookHealthCheck.checkClaude(hooksBinaryURL: binaryURL)
-                let codex = HookHealthCheck.checkCodex(hooksBinaryURL: binaryURL)
+                let claude = HookHealthCheck.checkClaude(
+                    hooksBinaryURL: binaryURL,
+                    expectsInstalledHooks: expectsClaude
+                )
+                let codex = HookHealthCheck.checkCodex(
+                    hooksBinaryURL: binaryURL,
+                    expectsInstalledHooks: expectsCodex
+                )
                 let openCode = HookHealthCheck.checkOpenCode()
                 return (claude, codex, openCode)
             }.value
@@ -798,6 +820,12 @@ final class HookInstallationCoordinator {
     /// install. `.untouched` and `.uninstalled` both return false;
     /// untouched agents are surfaced to the user via the first-run
     /// onboarding window and the empty-state banner instead.
+    /// Whether the user has asked for this agent's hooks, so a config with none
+    /// of ours in it is a fault worth reporting rather than the desired state.
+    func expectsInstalledHooks(_ agent: AgentIdentifier) -> Bool {
+        intentStore.intent(for: agent) == .installed
+    }
+
     func shouldAutoInstall(_ agent: AgentIdentifier) -> Bool {
         guard intentStore.intent(for: agent) == .installed else {
             return false

Sources/OpenIslandCore/ClaudeHookInstaller.swift

@@ -117,6 +117,7 @@ public enum ClaudeHookInstaller {
         var rootObject = try loadRootObject(from: existingData)
         var hooksObject = rootObject["hooks"] as? [String: Any] ?? [:]
         var mutated = false
+        var ownHooksPresent = false
 
         for spec in eventSpecs {
             let existingGroups = hooksObject[spec.name] as? [Any] ?? []
@@ -126,6 +127,10 @@ public enum ClaudeHookInstaller {
                 mutated = true
             }
 
+            if containsOwnManagedHook(in: existingGroups, managedCommand: managedCommand) {
+                ownHooksPresent = true
+            }
+
             if cleanedGroups.isEmpty {
                 hooksObject.removeValue(forKey: spec.name)
             } else {
@@ -143,7 +148,7 @@ public enum ClaudeHookInstaller {
         return ClaudeHookFileMutation(
             contents: contents,
             changed: mutated || contents != existingData,
-            managedHooksPresent: mutated,
+            managedHooksPresent: ownHooksPresent,
             hasClaudeIslandHooks: containsClaudeIslandHook(in: hooksObject)
         )
     }
@@ -230,6 +235,25 @@ public enum ClaudeHookInstaller {
         }
     }
 
+    /// Whether any hook in `groups` is one of ours.
+    /// The ownership counterpart to ``containsManagedHook(in:managedCommand:)``.
+    private static func containsOwnManagedHook(in groups: [Any], managedCommand: String?) -> Bool {
+        groups.contains { item in
+            guard let group = item as? [String: Any],
+                  let hooks = group["hooks"] as? [Any] else {
+                return false
+            }
+
+            return hooks.contains { hook in
+                guard let hook = hook as? [String: Any] else {
+                    return false
+                }
+
+                return isOwnManagedHook(hook, managedCommand: managedCommand)
+            }
+        }
+    }
+
     private static func containsClaudeIslandHook(in hooksObject: [String: Any]) -> Bool {
         hooksObject.values.contains { value in
             let groups = value as? [Any] ?? []
@@ -275,6 +299,10 @@ public enum ClaudeHookInstaller {
         return group
     }
 
+    /// Whether a hook entry should be dropped when we (re)write our own hooks.
+    /// Deliberately broad: it also covers the closed-source Vibe Island bridge
+    /// so a user migrating from that app doesn't end up with two islands
+    /// reacting to every event.
     private static func isManagedHook(_ hook: [String: Any], managedCommand: String?) -> Bool {
         guard let command = hook["command"] as? String else {
             return false
@@ -287,6 +315,30 @@ public enum ClaudeHookInstaller {
         return isLegacyOpenIslandHookCommand(command)
     }
 
+    /// Whether a hook entry is *ours* — the command we installed, or our hook
+    /// CLI under its current or pre-rename name.
+    ///
+    /// This is the question "are Open Island's hooks installed?", and it must
+    /// stay narrower than ``isManagedHook(_:managedCommand:)``. Answering it
+    /// with the broad predicate made a leftover `vibe-island-bridge` entry from
+    /// the closed-source app read as a successful install, which reported
+    /// "hooks installed" in Settings and suppressed the startup repair in
+    /// `shouldAutoInstall` — so no hook of ours ever ran.
+    private static func isOwnManagedHook(_ hook: [String: Any], managedCommand: String?) -> Bool {
+        guard let command = hook["command"] as? String else {
+            return false
+        }
+
+        if let managedCommand, command == managedCommand {
+            return true
+        }
+
+        // Path-independent fallback: the app bundle may have moved since
+        // install, which invalidates the recorded command but not ownership.
+        let normalized = command.lowercased()
+        return normalized.contains("openislandhooks") || normalized.contains("vibeislandhooks")
+    }
+
     private static func isManagedHookForInstall(_ hook: [String: Any], replacingCommand: String) -> Bool {
         if isManagedHook(hook, managedCommand: replacingCommand) {
             return true

Sources/OpenIslandCore/CodexHookInstallationManager.swift

@@ -62,7 +62,7 @@ public final class CodexHookInstallationManager: @unchecked Sendable {
         let managedHooksPresent = ((try? CodexHookInstaller.uninstallHooksJSON(
             existingData: hooksData,
             managedCommand: managedCommand
-        ))?.changed) == true
+        ))?.ownHooksPresent) == true
 
         return CodexHookInstallationStatus(
             codexDirectory: codexDirectory,

Sources/OpenIslandCore/CodexHookInstaller.swift

@@ -35,11 +35,26 @@ public struct CodexHookFileMutation: Equatable, Sendable {
     public var contents: Data?
     public var changed: Bool
     public var hasRemainingHooks: Bool
-
-    public init(contents: Data?, changed: Bool, hasRemainingHooks: Bool) {
+    /// Whether hooks of ours were actually found in the file.
+    ///
+    /// Distinct from ``changed``, which is also true when the file merely
+    /// re-serializes differently (we write sorted, pretty-printed JSON). Use
+    /// this — never ``changed`` — to answer "are our hooks installed?".
+    public var ownHooksPresent: Bool
+
+    /// - Parameter ownHooksPresent: Defaults to `false` so existing callers that
+    ///   only describe a write keep compiling; the uninstall path, which is the
+    ///   one asked about installed state, always passes it explicitly.
+    public init(
+        contents: Data?,
+        changed: Bool,
+        hasRemainingHooks: Bool,
+        ownHooksPresent: Bool = false
+    ) {
         self.contents = contents
         self.changed = changed
         self.hasRemainingHooks = hasRemainingHooks
+        self.ownHooksPresent = ownHooksPresent
     }
 }
 
@@ -133,12 +148,18 @@ public enum CodexHookInstaller {
         var rootObject = try loadRootObject(from: existingData)
         var hooksObject = rootObject["hooks"] as? [String: Any] ?? [:]
         var mutated = false
+        var ownHooksPresent = false
 
         for spec in eventSpecs {
             let existingGroups = hooksObject[spec.name] as? [Any] ?? []
             let cleanedGroups = sanitize(groups: existingGroups, managedCommand: managedCommand)
 
-            if cleanedGroups.count != existingGroups.count || containsManagedHook(in: existingGroups, managedCommand: managedCommand) {
+            let hadOwnHooks = containsManagedHook(in: existingGroups, managedCommand: managedCommand)
+            if hadOwnHooks {
+                ownHooksPresent = true
+            }
+
+            if cleanedGroups.count != existingGroups.count || hadOwnHooks {
                 mutated = true
             }
 
@@ -150,12 +171,22 @@ public enum CodexHookInstaller {
         }
 
         if hooksObject.isEmpty {
-            return CodexHookFileMutation(contents: nil, changed: mutated, hasRemainingHooks: false)
+            return CodexHookFileMutation(
+                contents: nil,
+                changed: mutated,
+                hasRemainingHooks: false,
+                ownHooksPresent: ownHooksPresent
+            )
         }
 
         rootObject["hooks"] = hooksObject
         let data = try serialize(rootObject)
-        return CodexHookFileMutation(contents: data, changed: mutated || data != existingData, hasRemainingHooks: true)
+        return CodexHookFileMutation(
+            contents: data,
+            changed: mutated || data != existingData,
+            hasRemainingHooks: true,
+            ownHooksPresent: ownHooksPresent
+        )
     }
 
     /// Enables the current Codex hooks feature flag and migrates the legacy flag when present.

Sources/OpenIslandCore/HookHealthCheck.swift

@@ -24,6 +24,9 @@ public struct HookHealthReport: Equatable, Sendable {
         case manifestMissing(expectedPath: String)
         /// The OpenCode plugin file is missing even though it should be installed.
         case pluginMissing(expectedPath: String)
+        /// The user asked for these hooks, but none of ours are in the config.
+        /// Usually another tool rewrote the file and dropped our entries.
+        case hooksMissing(configPath: String)
 
         public var description: String {
             switch self {
@@ -41,6 +44,8 @@ public struct HookHealthReport: Equatable, Sendable {
                 "Installation manifest missing: \(expectedPath)"
             case .pluginMissing(let expectedPath):
                 "OpenCode plugin file is missing: \(expectedPath)"
+            case .hooksMissing(let configPath):
+                "Open Island hooks are missing from \(configPath) — another tool may have rewritten it."
             }
         }
 
@@ -55,7 +60,7 @@ public struct HookHealthReport: Equatable, Sendable {
 
         public var isAutoRepairable: Bool {
             switch self {
-            case .staleCommandPath, .binaryNotExecutable, .manifestMissing, .pluginMissing:
+            case .staleCommandPath, .binaryNotExecutable, .manifestMissing, .pluginMissing, .hooksMissing:
                 true
             default:
                 false
@@ -97,10 +102,16 @@ public struct HookHealthReport: Equatable, Sendable {
 /// Performs deep health checks on hook installations, beyond the simple "managed hooks present" check.
 public enum HookHealthCheck {
     /// Check Claude Code hook health.
+    ///
+    /// - Parameter expectsInstalledHooks: Whether the user has asked for these
+    ///   hooks (persisted intent is `.installed`). Only then is an empty config
+    ///   a problem — otherwise "no hooks of ours" is the desired state, and
+    ///   reporting it would auto-repair hooks the user deliberately removed.
     public static func checkClaude(
         claudeDirectory: URL = ClaudeConfigDirectory.resolved(),
         hooksBinaryURL: URL? = nil,
         managedHooksBinaryURL: URL = ManagedHooksBinary.defaultURL(),
+        expectsInstalledHooks: Bool = false,
         fileManager: FileManager = .default
     ) -> HookHealthReport {
         var issues: [HookHealthReport.Issue] = []
@@ -151,13 +162,19 @@ public enum HookHealthCheck {
             }
         }
 
-        // 3. Check manifest
-        if fileManager.fileExists(atPath: settingsPath),
-           hasOpenIslandHooks(in: settingsURL, fileManager: fileManager) {
+        // 3. Check that our own hooks are actually there, and the manifest.
+        let hasOwnHooks = hasOpenIslandHooks(in: settingsURL, fileManager: fileManager)
+
+        if hasOwnHooks {
             let legacyManifestURL = claudeDirectory.appendingPathComponent(ClaudeHookInstallerManifest.legacyFileName)
             if !fileManager.fileExists(atPath: manifestURL.path) && !fileManager.fileExists(atPath: legacyManifestURL.path) {
                 issues.append(.manifestMissing(expectedPath: manifestURL.path))
             }
+        } else if expectsInstalledHooks, !issues.contains(.configMalformedJSON(path: settingsPath)) {
+            // Don't claim the hooks are gone when we couldn't parse the file —
+            // the malformed-JSON issue already describes that case, and
+            // re-installing over unparseable settings would not help.
+            issues.append(.hooksMissing(configPath: settingsPath))
         }
 
         return HookHealthReport(
@@ -169,10 +186,13 @@ public enum HookHealthCheck {
     }
 
     /// Check Codex hook health.
+    ///
+    /// - Parameter expectsInstalledHooks: See ``checkClaude(claudeDirectory:hooksBinaryURL:managedHooksBinaryURL:expectsInstalledHooks:fileManager:)``.
     public static func checkCodex(
         codexDirectory: URL = FileManager.default.homeDirectoryForCurrentUser.appendingPathComponent(".codex", isDirectory: true),
         hooksBinaryURL: URL? = nil,
         managedHooksBinaryURL: URL = ManagedHooksBinary.defaultURL(),
+        expectsInstalledHooks: Bool = false,
         fileManager: FileManager = .default
     ) -> HookHealthReport {
         var issues: [HookHealthReport.Issue] = []
@@ -214,13 +234,16 @@ public enum HookHealthCheck {
             }
         }
 
-        // 3. Check manifest
-        if fileManager.fileExists(atPath: hooksPath),
-           hasOpenIslandHooks(in: hooksURL, fileManager: fileManager) {
+        // 3. Check that our own hooks are actually there, and the manifest.
+        let hasOwnHooks = hasOpenIslandHooks(in: hooksURL, fileManager: fileManager)
+
+        if hasOwnHooks {
             let legacyManifestURL = codexDirectory.appendingPathComponent(CodexHookInstallerManifest.legacyFileName)
             if !fileManager.fileExists(atPath: manifestURL.path) && !fileManager.fileExists(atPath: legacyManifestURL.path) {
                 issues.append(.manifestMissing(expectedPath: manifestURL.path))
             }
+        } else if expectsInstalledHooks, !issues.contains(.configMalformedJSON(path: hooksPath)) {
+            issues.append(.hooksMissing(configPath: hooksPath))
         }
 
         return HookHealthReport(