@raidiant/notifai 2.0.1 → 3.0.1

package/src/commands.ts

@@ -102,7 +102,6 @@ import {
   applyPlan,
   buildCursorHookConfig,
   buildHookConfig,
-  collapseUnusedCodexRepresentation,
   codexLayerDir,
   codexLayerPaths,
   codexRepresentationProblems,
@@ -121,6 +120,7 @@ import {
   removeCursorHooks,
   removeHooks,
   settingsFile,
+  withCodexLayerTransaction,
   type Harness,
   type Installation,
 } from './install-hooks.js'
@@ -2382,12 +2382,17 @@ export function hooksInstallCommand(deps: CommandDeps, flags: HooksInstallFlags)
       return EXIT.failed
     }
   }
-  const file = settingsFile(harness, wantGlobal, deps.cwd, deps.env, hookPlatform)
+  const codexPaths =
+    harness === 'codex'
+      ? codexLayerPaths(wantGlobal, deps.cwd, deps.env, hookPlatform)
+      : null
+  const settingsTarget =
+    codexPaths?.configToml ?? settingsFile(harness, wantGlobal, deps.cwd, deps.env, hookPlatform)
 
   // OpenCode's adapter is a generated plugin module rather than a handler
   // merged into a settings document, so it owns the whole file.
   if (harness === 'opencode') {
-    return installOpencodePlugin(deps, file, {
+    return installOpencodePlugin(deps, settingsTarget, {
       adapterPath,
       timeoutSeconds: BLOCKING_STOP_TIMEOUT_SECONDS,
       platform: hookPlatform,
@@ -2397,8 +2402,8 @@ export function hooksInstallCommand(deps: CommandDeps, flags: HooksInstallFlags)
 
   if (harness === 'cursor') {
     try {
-      withTargetFileLock(file, () => {
-        const document = loadCursorSettings(file)
+      withTargetFileLock(settingsTarget, () => {
+        const document = loadCursorSettings(settingsTarget)
         const result = mergeCursorHooks(
           document,
           buildCursorHookConfig({
@@ -2409,43 +2414,40 @@ export function hooksInstallCommand(deps: CommandDeps, flags: HooksInstallFlags)
           }),
           scriptPath,
         )
-        applyPlan(file, result.document)
+        applyPlan(settingsTarget, result.document)
         return result
       })
     } catch (err) {
       deps.io.err(String(err))
       return EXIT.failed
     }
-    printHooksInstallClose(deps, harness, file)
+    printHooksInstallClose(deps, harness, settingsTarget)
     return EXIT.ok
   }
 
-  let foreignStopCount = 0
-  let collapsedFrom: string | null = null
+  const installInto = (file: string): { file: string; foreignStopCount: number } => {
+    const document = loadSettings(file)
+    const foreignStopCount = foreignStopHandlers(document).length
+    const result = mergeHooks(
+      document,
+      buildHookConfig({
+        adapterPath,
+        harness,
+        platform: hookPlatform,
+        nodePath,
+      }),
+      scriptPath,
+    )
+    applyPlan(file, result.document)
+    return { file, foreignStopCount }
+  }
+
+  let installed: { file: string; foreignStopCount: number }
   try {
-    withTargetFileLock(file, () => {
-      const document = loadSettings(file)
-      foreignStopCount = foreignStopHandlers(document).length
-      const result = mergeHooks(
-        document,
-        buildHookConfig({
-          adapterPath,
-          harness,
-          platform: hookPlatform,
-          nodePath,
-        }),
-        scriptPath,
-      )
-      applyPlan(file, result.document)
-      return result
-    })
-    if (harness === 'codex') {
-      collapsedFrom = collapseUnusedCodexRepresentation(
-        file,
-        scriptPath,
-        codexLayerPaths(flags.global ?? false, deps.cwd, deps.env),
-      )
-    }
+    installed =
+      codexPaths === null
+        ? withTargetFileLock(settingsTarget, () => installInto(settingsTarget))
+        : withCodexLayerTransaction(codexPaths, (inspection) => installInto(inspection.writeTarget))
   } catch (err) {
     deps.io.err(String(err))
     return EXIT.failed
@@ -2455,17 +2457,14 @@ export function hooksInstallCommand(deps: CommandDeps, flags: HooksInstallFlags)
     const layer = flags.global ? null : codexLayerDir(deps.cwd)
     if (layer !== null) mkdirSync(layer, { recursive: true })
   }
-  printHooksInstallClose(deps, harness, file)
-  if (collapsedFrom !== null) {
-    deps.io.out(`Collapsed ${collapsedFrom} onto ${file} so this layer has one representation.`)
-  }
-  if (foreignStopCount > 0) {
+  printHooksInstallClose(deps, harness, installed.file)
+  if (installed.foreignStopCount > 0) {
     deps.io.out(
       "This layer already has a Stop handler. Codex runs every matching handler, so Notifai's Stop and the existing one will both fire.",
     )
   }
   if (harness === 'codex') {
-    for (const problem of codexRepresentationProblems(deps.cwd, deps.env)) {
+    for (const problem of codexRepresentationProblems(deps.cwd, deps.env, hookPlatform)) {
       deps.io.out(problem)
     }
   }
@@ -2522,13 +2521,13 @@ export function hooksUninstallCommand(deps: CommandDeps, flags: HooksInstallFlag
   const harness = resolveHarness(deps, flags.harness)
   if (!harness) return EXIT.usage
   const scriptPath = flags.scriptPath ?? process.argv[1] ?? 'notifai'
-  const file = settingsFile(
-    harness,
-    flags.global ?? false,
-    deps.cwd,
-    deps.env,
-    deps.hookPlatform,
-  )
+  const global = flags.global ?? false
+  const codexPaths =
+    harness === 'codex'
+      ? codexLayerPaths(global, deps.cwd, deps.env, deps.hookPlatform)
+      : null
+  const file =
+    codexPaths?.configToml ?? settingsFile(harness, global, deps.cwd, deps.env, deps.hookPlatform)
   if (harness === 'opencode') {
     try {
       return withTargetFileLock(file, () => {
@@ -2576,32 +2575,48 @@ export function hooksUninstallCommand(deps: CommandDeps, flags: HooksInstallFlag
     )
     return EXIT.ok
   }
-  const files = hookDefinitionFiles(harness, flags.global ?? false, deps.cwd, deps.env)
-  const existing = files.filter((candidate) => existsSync(candidate))
-  if (existing.length === 0) {
-    deps.io.out(`Nothing to remove: ${file} does not exist.`)
-    return EXIT.ok
-  }
-  let removedAny = false
-  try {
+  const removeInstalledHooks = (): { existing: string[]; removedAny: boolean } => {
+    const files =
+      codexPaths === null
+        ? hookDefinitionFiles(harness, global, deps.cwd, deps.env, deps.hookPlatform)
+        : [codexPaths.hooksJson, codexPaths.configToml]
+    const existing = files.filter((candidate) => existsSync(candidate))
+    let removedAny = false
     for (const candidate of existing) {
-      const stripped = withTargetFileLock(candidate, () => {
+      const removeFromCandidate = () => {
         const document = loadSettings(candidate)
         const result = removeHooks(document, scriptPath)
-        applyPlan(candidate, result.document)
+        if (result.replaced.length > 0) applyPlan(candidate, result.document)
         return result
-      })
+      }
+      const stripped =
+        codexPaths === null
+          ? withTargetFileLock(candidate, removeFromCandidate)
+          : removeFromCandidate()
       if (stripped.replaced.length > 0) {
         removedAny = true
         deps.io.out(`Removed Notifai hooks (${stripped.replaced.join(', ')}) from ${candidate}`)
       }
     }
+    return { existing, removedAny }
+  }
+
+  let result: { existing: string[]; removedAny: boolean }
+  try {
+    result =
+      codexPaths === null
+        ? removeInstalledHooks()
+        : withCodexLayerTransaction(codexPaths, removeInstalledHooks)
   } catch (err) {
     deps.io.err(String(err))
     return EXIT.failed
   }
-  if (!removedAny) {
-    deps.io.out(`No Notifai hooks found in ${existing.join(', ')}`)
+  if (result.existing.length === 0) {
+    deps.io.out(`Nothing to remove: ${file} does not exist.`)
+    return EXIT.ok
+  }
+  if (!result.removedAny) {
+    deps.io.out(`No Notifai hooks found in ${result.existing.join(', ')}`)
   }
   return EXIT.ok
 }
@@ -4896,23 +4911,16 @@ function hookChecks(deps: CommandDeps): HookCheck[] {
     })
   }
 
-  const representationProblems = codexRepresentationProblems(deps.cwd, deps.env)
+  const representationProblems = codexRepresentationProblems(
+    deps.cwd,
+    deps.env,
+    deps.hookPlatform,
+  )
   if (representationProblems.length > 0) {
-    const collapseCommand = representationProblems.some((problem) => problem.includes('--global'))
-      ? 'notifai hooks install --harness codex --global'
-      : 'notifai hooks install --harness codex'
     checks.push({
       name: 'hooks (codex representation)',
       ok: false,
       detail: representationProblems.join('; '),
-      ...(representationProblems.some((problem) => problem.includes('to collapse onto'))
-        ? {
-            remedy: {
-              summary: 'collapse this Codex layer onto a single hook file',
-              command: collapseCommand,
-            },
-          }
-        : {}),
     })
   }
 

package/src/hooks.test.ts

@@ -158,6 +158,7 @@ function fakeClient(recorder: Recorder, replies: ReplyView[]): ApiClient {
       }
     },
     createMediaUpload: notUsed,
+    finalizeMediaUpload: notUsed,
     uploadMedia: notUsed,
     health: async () => true,
     submit: async (body) => {

package/src/install-hooks.test.ts

@@ -253,15 +253,12 @@ describe('settings locations', () => {
     expect(settingsFile('claude-code', true, '/repo', {})).toBe(
       path.join(process.env['HOME']!, '.claude', 'settings.json'),
     )
-    expect(settingsFile('codex', true, '/repo', {})).toBe(
-      path.join(process.env['HOME']!, '.codex', 'hooks.json'),
-    )
   })
 
-  it('uses the dedicated Codex hooks file for a new layer', () => {
-    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/hooks.json')
+  it('uses inline Codex hooks for a new layer', () => {
+    expect(settingsFile('codex', false, '/repo', {})).toBe('/repo/.codex/config.toml')
     expect(settingsFile('codex', true, '/repo', {})).toBe(
-      path.join(os.homedir(), '.codex', 'hooks.json'),
+      path.join(os.homedir(), '.codex', 'config.toml'),
     )
   })
 
@@ -273,67 +270,24 @@ describe('settings locations', () => {
     expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'hooks.json'))
   })
 
-  it('keeps a Notifai-only inline representation so existing trust remains valid', () => {
-    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-ours-toml-'))
-    mkdirSync(path.join(repo, '.codex'), { recursive: true })
-    applyPlan(path.join(repo, '.codex', 'config.toml'), { hooks: ours() })
-
-    expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'config.toml'))
-  })
-
-  it('stays on hooks.json when that file already holds someone else\'s hooks', () => {
+  it('stays on hooks.json when it alone has hooks, even if config.toml already exists', () => {
     const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-foreign-json-'))
-    mkdirSync(path.join(repo, '.codex'), { recursive: true })
-    applyPlan(path.join(repo, '.codex', 'hooks.json'), {
+    const layer = path.join(repo, '.codex')
+    mkdirSync(layer, { recursive: true })
+    writeFileSync(
+      path.join(layer, 'config.toml'),
+      `[hooks.state."${layer}/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
+    )
+    applyPlan(path.join(layer, 'hooks.json'), {
       hooks: {
         Stop: [{ hooks: [{ type: 'command', command: 'gdh-stop' }] }],
       },
     })
 
-    expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'hooks.json'))
-  })
-
-  it('writes Codex hooks into an existing inline [hooks] instead of inventing hooks.json', () => {
-    const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-toml-layer-'))
-    mkdirSync(path.join(repo, '.codex'), { recursive: true })
-    writeFileSync(
-      path.join(repo, '.codex', 'config.toml'),
-      [
-        'model = "gpt-5.6"',
-        '',
-        '[[hooks.PostToolUse]]',
-        'matcher = "Bash"',
-        '',
-        '[[hooks.PostToolUse.hooks]]',
-        'type = "command"',
-        'command = "gdh-guard"',
-        '',
-        '[[hooks.Stop]]',
-        '',
-        '[[hooks.Stop.hooks]]',
-        'type = "command"',
-        'command = "gdh-stop"',
-        '',
-      ].join('\n'),
-    )
-
-    expect(settingsFile('codex', false, repo, {})).toBe(path.join(repo, '.codex', 'config.toml'))
-  })
-
-  it('does not treat the Codex trust store as an inline hook representation', () => {
-    const home = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-trust-only-'))
-    mkdirSync(path.join(home, '.codex'), { recursive: true })
-    writeFileSync(
-      path.join(home, '.codex', 'config.toml'),
-      `[hooks.state."${home}/.codex/hooks.json:stop:0:0"]\ntrusted_hash = "sha256:abc"\n`,
-    )
-
-    expect(settingsFile('codex', true, '/repo', { HOME: home, CODEX_HOME: path.join(home, '.codex') })).toBe(
-      path.join(home, '.codex', 'hooks.json'),
-    )
+    expect(settingsFile('codex', false, repo, {})).toBe(path.join(layer, 'hooks.json'))
   })
 
-  it('preserves foreign inline hooks when both representations exist', () => {
+  it('does not migrate our hooks when both representations already exist', () => {
     const repo = mkdtempSync(path.join(os.tmpdir(), 'notifai-codex-both-'))
     const layer = path.join(repo, '.codex')
     mkdirSync(layer, { recursive: true })
@@ -345,7 +299,7 @@ describe('settings locations', () => {
     )
     applyPlan(path.join(layer, 'hooks.json'), { hooks: ours() })
 
-    expect(settingsFile('codex', false, repo, {})).toBe(path.join(layer, 'config.toml'))
+    expect(settingsFile('codex', false, repo, {})).toBe(path.join(layer, 'hooks.json'))
   })
 })
 
@@ -371,7 +325,7 @@ describe('a Codex install run inside a git worktree', () => {
   it('targets the main repository, which is the file Codex actually reads', () => {
     const { main, worktree } = repoWithWorktree()
 
-    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'hooks.json'))
+    expect(settingsFile('codex', false, worktree, {})).toBe(path.join(main, '.codex', 'config.toml'))
     expect(codexProjectRoot(worktree)).toBe(main)
   })
 
@@ -438,7 +392,7 @@ describe('a Codex install run inside a git worktree', () => {
 
   it('follows the active harness home for global hook install', () => {
     expect(settingsFile('codex', true, '/repo', { HOME: '/user', CODEX_HOME: '/managed/codex' })).toBe(
-      '/managed/codex/hooks.json',
+      '/managed/codex/config.toml',
     )
     expect(settingsFile('claude-code', true, '/repo', { CLAUDE_CONFIG_DIR: '/managed/claude' })).toBe(
       '/managed/claude/settings.json',

package/src/install-hooks.ts

@@ -3,13 +3,13 @@ import {
   lstatSync,
   readFileSync,
   realpathSync,
-  rmSync,
   statSync,
 } from 'node:fs'
 import { createHash } from 'node:crypto'
 import path from 'node:path'
 import { parse as parseToml, stringify as stringifyToml } from 'smol-toml'
 import { atomicWriteFileSync } from './atomic-file.js'
+import { withTargetFileLock } from './file-lock.js'
 import {
   hookAdapterPath,
   hookHostPlatform,
@@ -41,8 +41,9 @@ const OPENCODE_EVENTS = [
  * with an optional timeout — so one generator serves both. Only the file
  * location and the event set differ. Codex supports either a dedicated
  * `hooks.json` or inline `[hooks]` tables in the same layer's `config.toml`.
- * We default to the dedicated file so installing hooks never rewrites Codex's
- * main configuration and trust store. One representation per layer, never both.
+ * We default a hook-empty layer to inline config and preserve whichever single
+ * representation a populated layer already uses. One representation per layer,
+ * never both.
  *
  * Cursor's native format is flat and lower-camel-cased, while OpenCode's
  * extension point is a JavaScript plugin module. Each therefore has a bounded
@@ -492,37 +493,32 @@ export interface CodexLayerInspection {
   writeTarget: string
   dual: boolean
   overlappingEvents: string[]
-  canCollapse: boolean
 }
 
 /**
  * Which representation this Codex layer already uses.
  *
  * Codex supports `hooks.json` and inline `[hooks]` side by side, but loads both
- * and runs every matching handler. Prefer the dedicated file for a new layer;
+ * and runs every matching handler. Use inline config for a hook-empty layer and
  * preserve an existing single representation so installing Notifai never
- * invents a dual layer. `[hooks.state]` is the trust store, not a hook
- * definition, so it does not count as a representation.
+ * invents a dual layer. When the layer is already dual, keep our handlers in
+ * the representation that already contains them instead of silently migrating
+ * them. `[hooks.state]` is the trust store, not a hook definition, so it does
+ * not count as a representation.
  */
 export function inspectCodexLayer(paths: CodexLayerPaths): CodexLayerInspection {
   const jsonDocument = tryLoadSettings(paths.hooksJson)
   const tomlDocument = tryLoadSettings(paths.configToml)
   const jsonEvents = hookEventNames(jsonDocument?.hooks)
   const tomlEvents = hookEventNames(tomlDocument?.hooks)
-  const jsonForeign = documentHasForeignHandlers(jsonDocument)
-  const tomlForeign = documentHasForeignHandlers(tomlDocument)
-  const jsonOurs = documentHasOurHandlers(jsonDocument)
-  const tomlOurs = documentHasOurHandlers(tomlDocument)
   const dual = jsonEvents.length > 0 && tomlEvents.length > 0
-  let writeTarget = paths.hooksJson
-  if (tomlEvents.length > 0 && jsonEvents.length === 0) {
-    writeTarget = paths.configToml
+  let writeTarget = paths.configToml
+  if (jsonEvents.length > 0 && tomlEvents.length === 0) {
+    writeTarget = paths.hooksJson
   } else if (dual) {
-    if (tomlForeign && !jsonForeign) writeTarget = paths.configToml
-    else if (jsonForeign && !tomlForeign) writeTarget = paths.hooksJson
-    else if (!jsonForeign && !tomlForeign) writeTarget = paths.hooksJson
-    else if (tomlOurs && !jsonOurs) writeTarget = paths.configToml
-    else writeTarget = paths.hooksJson
+    const jsonOurs = documentHasOurHandlers(jsonDocument)
+    const tomlOurs = documentHasOurHandlers(tomlDocument)
+    if (jsonOurs && !tomlOurs) writeTarget = paths.hooksJson
   }
   return {
     paths,
@@ -530,11 +526,23 @@ export function inspectCodexLayer(paths: CodexLayerPaths): CodexLayerInspection
     tomlEvents,
     writeTarget,
     dual,
-    overlappingEvents: jsonEvents.filter((event) => tomlEvents.includes(event)),
-    canCollapse: dual && !(jsonForeign && tomlForeign),
+    overlappingEvents: dual
+      ? jsonEvents.filter((event) => tomlEvents.includes(event))
+      : [],
   }
 }
 
+/**
+ * Serialize one Notifai transaction across both representations in a Codex
+ * layer, then inspect that layer only after acquiring the shared anchor.
+ */
+export function withCodexLayerTransaction<T>(
+  paths: CodexLayerPaths,
+  action: (inspection: CodexLayerInspection) => T,
+): T {
+  return withTargetFileLock(paths.configToml, () => action(inspectCodexLayer(paths)))
+}
+
 /** Every file in this layer Codex might already be reading hooks from. */
 export function hookDefinitionFiles(
   harness: Harness,
@@ -548,47 +556,20 @@ export function hookDefinitionFiles(
   return [paths.hooksJson, paths.configToml]
 }
 
-/**
- * Drop the unused representation after writing the one this layer already had.
- *
- * Only safe when the discarded file has no one else's handlers. `hooks.json`
- * is deleted once it has no events left so Codex stops warning; `config.toml`
- * is never deleted.
- */
-export function collapseUnusedCodexRepresentation(
-  keepFile: string,
-  scriptPath: string,
-  paths: CodexLayerPaths,
-): string | null {
-  const other = keepFile === paths.hooksJson ? paths.configToml : paths.hooksJson
-  if (!existsSync(other)) return null
-  const document = tryLoadSettings(other)
-  if (document === null || documentHasForeignHandlers(document)) return null
-  const stripped = removeHooks(document, scriptPath)
-  if (other === paths.hooksJson && hookEventNames(stripped.document.hooks).length === 0) {
-    rmSync(other)
-    return other
-  }
-  applyPlan(other, stripped.document)
-  return other
-}
-
 export function codexRepresentationProblems(
   cwd: string,
   env: NodeJS.ProcessEnv = process.env,
+  platform: NodeJS.Platform | HookHostPlatform = process.platform,
 ): string[] {
   return [false, true].flatMap((global) => {
-    const layer = inspectCodexLayer(codexLayerPaths(global, cwd, env))
+    const layer = inspectCodexLayer(codexLayerPaths(global, cwd, env, platform))
     if (!layer.dual) return []
     const overlap =
       layer.overlappingEvents.length > 0
         ? ` Matching handlers from both files all run — this layer's ${layer.overlappingEvents.join(', ')} handlers will both fire.`
         : ' Matching handlers from both files all run.'
-    const collapse = layer.canCollapse
-      ? ` Run \`notifai hooks install --harness codex${global ? ' --global' : ''}\` to collapse onto ${path.basename(layer.writeTarget)}.`
-      : ' Both files have other hooks, so Notifai cannot collapse them.'
     return [
-      `loading hooks from both ${layer.paths.hooksJson} and ${layer.paths.configToml}; prefer a single representation for this layer.${overlap}${collapse}`,
+      `loading hooks from both ${layer.paths.hooksJson} and ${layer.paths.configToml}; prefer a single representation for this layer.${overlap} Notifai preserves existing representations instead of migrating them automatically.`,
     ]
   })
 }
@@ -608,11 +589,6 @@ function hookEventNames(hooks: SettingsDocument['hooks']): string[] {
     .map(([event]) => event)
 }
 
-function documentHasForeignHandlers(document: SettingsDocument | null): boolean {
-  if (document === null) return false
-  return locateAllHandlers(document).some((handler) => !isNotifaiCommand(handler.command))
-}
-
 function documentHasOurHandlers(document: SettingsDocument | null): boolean {
   if (document === null) return false
   return locateHandlers(document).length > 0