Merge pull request #4553 from code-yeongyu/ulw/codex-hephaestus-dup

fix: skip claude hook injection for internal prompts

src/features/background-agent/background-task-notification-template.test.ts

@@ -4,6 +4,27 @@ import { unsafeTestValue } from "../../../test-support/unsafe-test-value"
 
 describe("buildBackgroundTaskNotificationText", () => {
   describe("#given one task still running after a completed task notification", () => {
+    test("#when building the partial notification #then it does not use the final completed heading", () => {
+      // given
+      const notification = buildBackgroundTaskNotificationText({
+        task: {
+          id: "task-1",
+          description: "Index repo",
+          status: "completed",
+        },
+        duration: "42s",
+        statusText: "COMPLETED",
+        allComplete: false,
+        remainingCount: 1,
+        completedTasks: [],
+      })
+
+      // then
+      expect(notification).not.toContain("[BACKGROUND TASK COMPLETED]")
+      expect(notification).toContain("[BACKGROUND TASK RESULT READY]")
+      expect(notification).toContain("You WILL be notified when ALL complete.")
+    })
+
     test("#when building the partial notification #then it preserves the existing completed-task format", () => {
       // given
       const notification = buildBackgroundTaskNotificationText({
@@ -21,7 +42,7 @@ describe("buildBackgroundTaskNotificationText", () => {
 
       // when
       const expectedNotification = `<system-reminder>
-[BACKGROUND TASK COMPLETED]
+[BACKGROUND TASK RESULT READY]
 **ID:** \`task-1\`
 **Description:** Index repo
 **Duration:** 42s
@@ -156,6 +177,32 @@ Use \`background_output(task_id="<id>")\` to retrieve each result.
   })
 
   describe("#given a completed task with retry attempt history", () => {
+    test("#when building the final notification #then it includes the final completed heading", () => {
+      // given
+      const notification = buildBackgroundTaskNotificationText({
+        task: {
+          id: "task-3",
+          description: "Fallback task",
+          status: "completed",
+        },
+        duration: "10s",
+        statusText: "COMPLETED",
+        allComplete: true,
+        remainingCount: 0,
+        completedTasks: [
+          {
+            id: "task-3",
+            description: "Fallback task",
+            status: "completed",
+          },
+        ],
+      })
+
+      // then
+      expect(notification).toContain("[BACKGROUND TASK COMPLETED]")
+      expect(notification).toContain("[ALL BACKGROUND TASKS COMPLETE]")
+    })
+
     test("#when building the final notification #then it renders the spec-aligned balanced attempt timeline", () => {
       // given
       const notification = buildBackgroundTaskNotificationText({

src/features/background-agent/background-task-notification-template.ts

@@ -85,7 +85,7 @@ export function buildBackgroundTaskNotificationText(input: {
     const hasFailures = failedTasks.length > 0
     const header = hasFailures
       ? `[ALL BACKGROUND TASKS FINISHED - ${failedTasks.length} FAILED]`
-      : "[ALL BACKGROUND TASKS COMPLETE]"
+      : "[BACKGROUND TASK COMPLETED]\n[ALL BACKGROUND TASKS COMPLETE]"
 
     let body = ""
     if (succeededText) {
@@ -108,9 +108,10 @@ Use \`background_output(task_id="<id>")\` to retrieve each result.${hasFailures
   }
 
   const isFailure = statusText !== "COMPLETED"
+  const header = isFailure ? `[BACKGROUND TASK ${statusText}]` : "[BACKGROUND TASK RESULT READY]"
 
   return `<system-reminder>
-[BACKGROUND TASK ${statusText}]
+${header}
 **ID:** \`${task.id}\`
 **Description:** ${safeDescription(task)}
 **Duration:** ${duration}${errorInfo}

src/features/background-agent/task-completion-cleanup.test.ts

@@ -390,7 +390,7 @@ describe("BackgroundManager.notifyParentSession cleanup scheduling", () => {
       expect(promptAsyncCalls).toHaveLength(1)
       expect(promptAsyncCalls[0]?.body.noReply).toBe(true)
       const notificationPayload = JSON.stringify(promptAsyncCalls[0]?.body.parts)
-      expect(notificationPayload).toContain("BACKGROUND TASK COMPLETED")
+      expect(notificationPayload).toContain("BACKGROUND TASK RESULT READY")
       expect(notificationPayload).not.toContain("ALL BACKGROUND TASKS COMPLETE")
     })
 

src/hooks/claude-code-hooks/handlers/chat-message-handler.ts

@@ -50,6 +50,7 @@ export function createChatMessageHandler(
 		})
 
 		const messageParts: MessagePart[] = textParts.map((p) => ({
+			...p,
 			type: "text",
 			text: p.text,
 		}))

src/hooks/claude-code-hooks/user-prompt-submit.test.ts

@@ -1,10 +1,16 @@
-import { describe, it, expect } from "bun:test"
+import { afterEach, describe, expect, it, mock, spyOn } from "bun:test"
+import { OMO_INTERNAL_INITIATOR_MARKER } from "../../shared/internal-initiator-marker"
+import * as dispatchHookModule from "./dispatch-hook"
 import {
   executeUserPromptSubmitHooks,
   type UserPromptSubmitContext,
 } from "./user-prompt-submit"
 
 describe("executeUserPromptSubmitHooks", () => {
+  afterEach(() => {
+    mock.restore()
+  })
+
   it("returns early when no config provided", async () => {
     // given
     const ctx: UserPromptSubmitContext = {
@@ -104,4 +110,65 @@ describe("executeUserPromptSubmitHooks", () => {
     expect(result1.block).toBe(false)
     expect(result2.block).toBe(false)
   })
+
+  it("#given synthetic hook context only #when prompt submit runs #then hook command is not dispatched", async () => {
+    // given
+    const dispatchSpy = spyOn(dispatchHookModule, "dispatchHook").mockResolvedValue({
+      exitCode: 0,
+      stdout: "hook output",
+      stderr: "",
+    })
+    const ctx: UserPromptSubmitContext = {
+      sessionId: "test-session-synthetic",
+      prompt: "synthetic hook message",
+      parts: [{ type: "text", text: "synthetic hook message", synthetic: true }],
+      cwd: "/tmp",
+    }
+    const config = {
+      UserPromptSubmit: [
+        { matcher: "*", hooks: [{ type: "command" as const, command: "echo hook" }] },
+      ],
+    }
+
+    // when
+    const result = await executeUserPromptSubmitHooks(ctx, config)
+
+    // then
+    expect(result.block).toBe(false)
+    expect(result.messages).toEqual([])
+    expect(dispatchSpy).toHaveBeenCalledTimes(0)
+  })
+
+  it("#given internal prompt marker only #when prompt submit runs #then hook command is not dispatched", async () => {
+    // given
+    const dispatchSpy = spyOn(dispatchHookModule, "dispatchHook").mockResolvedValue({
+      exitCode: 0,
+      stdout: "hook output",
+      stderr: "",
+    })
+    const ctx: UserPromptSubmitContext = {
+      sessionId: "test-session-internal",
+      prompt: `internal hook message\n${OMO_INTERNAL_INITIATOR_MARKER}`,
+      parts: [
+        {
+          type: "text",
+          text: `internal hook message\n${OMO_INTERNAL_INITIATOR_MARKER}`,
+        },
+      ],
+      cwd: "/tmp",
+    }
+    const config = {
+      UserPromptSubmit: [
+        { matcher: "*", hooks: [{ type: "command" as const, command: "echo hook" }] },
+      ],
+    }
+
+    // when
+    const result = await executeUserPromptSubmitHooks(ctx, config)
+
+    // then
+    expect(result.block).toBe(false)
+    expect(result.messages).toEqual([])
+    expect(dispatchSpy).toHaveBeenCalledTimes(0)
+  })
 })

src/hooks/claude-code-hooks/user-prompt-submit.ts

@@ -4,6 +4,7 @@ import type {
   ClaudeHooksConfig,
 } from "./types"
 import { findMatchingHooks, log } from "../../shared"
+import { isRealUserTextPart } from "../../shared/internal-initiator-marker"
 import { dispatchHook, getHookIdentifier } from "./dispatch-hook"
 import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
 
@@ -44,10 +45,14 @@ export async function executeUserPromptSubmitHooks(
     return { block: false, modifiedParts, messages }
   }
 
+  const realUserTextParts = ctx.parts.filter(isRealUserTextPart)
+  if (realUserTextParts.length === 0) {
+    return { block: false, modifiedParts, messages }
+  }
+
   // Check if hook tags are in the current user input only (not in injected context)
   // by checking only the text parts that were provided in this message
-  const userInputText = ctx.parts
+  const userInputText = realUserTextParts
-    .filter((p) => p.type === "text" && p.text)
     .map((p) => p.text ?? "")
     .join("\n")