Fix empty tool_output in transcripts for subagent tools (#179)

* Enable keyword detection on first message using direct parts transformation

Previously, first messages were skipped entirely to avoid interfering with title generation.
Now, keywords detected on the first message are injected directly into the message parts
instead of using the hook message injection system, allowing keywords like 'ultrawork' to
activate on the first message of a session.

This change:
- Removes the early return that skipped first message keyword detection
- Moves keyword context generation before the isFirstMessage check
- For first messages: transforms message parts directly by prepending keyword context
- For subsequent messages: maintains existing hook message injection behavior

🤖 GENERATED WITH ASSISTANCE OF [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)

* Preserve agent context in preemptive compaction's continue message

When sending the 'Continue' message after compaction, now includes the
original agent parameter from the stored message. Previously, the Continue
message was sent without the agent parameter, causing OpenCode to use the
default 'build' agent instead of preserving the original agent context
(e.g., Sisyphus).

Implementation:
- Get messageDir using getMessageDir(sessionID)
- Retrieve storedMessage using findNearestMessageWithFields
- Pass agent: storedMessage?.agent to promptAsync body

🤖 Generated with assistance of [OhMyOpenCode](https://github.com/code-yeongyu/oh-my-opencode)

* Fix tool_result recording for call_omo_agent to include output in transcripts (#177)

- Check if metadata is empty before using it
- Wrap output.output in structured object when metadata is missing
- Ensures plugin tools (call_omo_agent, background_task, task) that return strings are properly recorded in transcripts instead of empty {}

🤖 Generated with assistance of OhMyOpenCode

Author: code-yeongyu

src/hooks/claude-code-hooks/index.ts

@@ -184,7 +184,13 @@ export function createClaudeCodeHooksHook(ctx: PluginInput, config: PluginConfig
 
       const cachedInput = getToolInput(input.sessionID, input.tool, input.callID) || {}
 
-      recordToolResult(input.sessionID, input.tool, cachedInput, (output.metadata as Record<string, unknown>) || {})
+      // Use metadata if available and non-empty, otherwise wrap output.output in a structured object
+      // This ensures plugin tools (call_omo_agent, background_task, task) that return strings
+      // get their results properly recorded in transcripts instead of empty {}
+      const metadata = output.metadata as Record<string, unknown> | undefined
+      const hasMetadata = metadata && typeof metadata === "object" && Object.keys(metadata).length > 0
+      const toolOutput = hasMetadata ? metadata : { output: output.output }
+      recordToolResult(input.sessionID, input.tool, cachedInput, toolOutput)
 
       if (!isHookDisabled(config, "PostToolUse")) {
         const postClient: PostToolUseClient = {

src/hooks/keyword-detector/index.ts

@@ -25,18 +25,26 @@ export function createKeywordDetectorHook() {
       const isFirstMessage = !sessionFirstMessageProcessed.has(input.sessionID)
       sessionFirstMessageProcessed.add(input.sessionID)
 
-      if (isFirstMessage) {
-        log("Skipping keyword detection on first message for title generation", { sessionID: input.sessionID })
-        return
-      }
-
       const promptText = extractPromptText(output.parts)
       const messages = detectKeywords(promptText)
 
       if (messages.length === 0) {
         return
       }
 
+      const context = messages.join("\n")
+
+      // First message: transform parts directly (for title generation compatibility)
+      if (isFirstMessage) {
+        log(`Keywords detected on first message, transforming parts directly`, { sessionID: input.sessionID, keywordCount: messages.length })
+        const idx = output.parts.findIndex((p) => p.type === "text" && p.text)
+        if (idx >= 0) {
+          output.parts[idx].text = `${context}\n\n---\n\n${output.parts[idx].text ?? ""}`
+        }
+        return
+      }
+
+      // Subsequent messages: inject as separate message
       log(`Keywords detected: ${messages.length}`, { sessionID: input.sessionID })
 
       const message = output.message as {
@@ -46,7 +54,6 @@ export function createKeywordDetectorHook() {
         tools?: Record<string, boolean>
       }
 
-      const context = messages.join("\n")
       log(`[keyword-detector] Injecting context for ${messages.length} keywords`, { sessionID: input.sessionID, contextLength: context.length })
       const success = injectHookMessage(input.sessionID, context, {
         agent: message.agent,

src/hooks/preemptive-compaction/index.ts

@@ -184,9 +184,15 @@ export function createPreemptiveCompactionHook(
 
       setTimeout(async () => {
         try {
+          const messageDir = getMessageDir(sessionID)
+          const storedMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
+
           await ctx.client.session.promptAsync({
             path: { id: sessionID },
-            body: { parts: [{ type: "text", text: "Continue" }] },
+            body: {
+              agent: storedMessage?.agent,
+              parts: [{ type: "text", text: "Continue" }],
+            },
             query: { directory: ctx.directory },
           })
         } catch {}