@syengup/friday-channel-next 1.0.3 → 1.0.4

package/dist/index.js

@@ -16,8 +16,6 @@ import { ensureCodexReasoningSummary } from "./src/codex-reasoning-config.js";
 const hookLogger = createFridayNextLogger("hook");
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
-/** `api.on` returns void — register tool hooks at most once per process. */
-let fridayNextToolHooksRegistered = false;
 let disposeAgentEventListener = null;
 /**
  * Track the last `api` instance on which HTTP routes were registered.
@@ -142,10 +140,17 @@ export default defineChannelPluginEntry({
                 total: event.usage?.total,
             }, event.model, event.provider);
         });
-        if (fridayNextToolHooksRegistered) {
+        // Tool hooks (subagent_delivery_target / before_tool_call / after_tool_call) must follow the
+        // SAME re-registration discipline as the HTTP routes and onAgentEvent listener above. When the
+        // health-monitor restarts the plugin, `registerFull` receives a fresh `api` and the host
+        // dispatches hooks on THAT api; hooks left bound to the first api go silent for the rest of the
+        // process. The old one-time boolean guard bound them to whichever api arrived first — which is
+        // exactly why Codex `command_output` (the A3 after_tool_call stdout synthesis) fired on some
+        // gateway processes and not others. Re-register on every genuinely-new api; skip only a repeat
+        // call with the same api (matching the `!sameApi` gate the routes use).
+        if (sameApi) {
             return;
         }
-        fridayNextToolHooksRegistered = true;
         // Make Codex (ChatGPT/OAuth) models emit reasoning summary text so the app can stream
         // "thinking". OpenClaw never sets this; we assert it on the plugin side. Best-effort.
         ensureCodexReasoningSummary((msg) => hookLogger.info(msg));

package/dist/src/friday-session.js

@@ -346,12 +346,18 @@ export function forwardAgentEventRaw(evt) {
     // Codex app-server projects every tool/command call onto BOTH the standard `tool` stream
     // (carrying args + the real result) AND a redundant `item` event (kind:"tool"/"command"),
     // and core flags that item `suppressChannelProgress: true` ("do not surface in channel
-    // progress"). Forwarding the suppressed item anyway double-renders every non-exec tool in
-    // the app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing
-    // only on the first. Honor the flag and drop suppressed items; the `tool` stream (and, for
-    // exec, the synthesized `command_output`) already carries everything the app renders. Codex
-    // reasoning items (preamble/analysis) are NOT suppressed, so this never touches thinking.
-    if (evt.stream === "item" && evt.data.suppressChannelProgress === true) {
+    // progress"). Forwarding the suppressed *tool* item double-renders every non-exec tool in the
+    // app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing only
+    // on the first. So drop ONLY suppressed `kind:"tool"` items.
+    //
+    // BUT keep suppressed `kind:"command"`/`"process"` items: the `tool` stream's exec result is
+    // just {exitCode,duration} (no stdout), and the app bootstraps its command-terminal row from
+    // the `item kind:command` event — that row is what the synthesized `command_output` end event
+    // then attaches the real stdout to. Dropping it left exec tools with a command line and no
+    // output in the trace. (Reasoning items preamble/analysis are never suppressed.)
+    if (evt.stream === "item" &&
+        evt.data.suppressChannelProgress === true &&
+        evt.data.kind === "tool") {
         return;
     }
     // Register sessionKey → runId so we can resolve parentRunId

package/dist/src/history/normalize-message.js

@@ -91,6 +91,21 @@ function parseContent(content) {
                 }
                 break;
             }
+            case "toolResult":
+            case "tool_result": {
+                // Codex (app-server backend) persists an exec/bash tool's STDOUT in a content
+                // block whose `type` is "toolResult" (not "text") — the output lives in the
+                // block's `text`/`content`. The native/Anthropic path uses plain "text" blocks,
+                // so this case was never hit and the command output was silently dropped from
+                // history (`parsed.text` stayed ""), leaving the app's trace tool row with no
+                // result. ControlUI shows it because its projection reads these blocks.
+                const t = readString(block.text) || readString(block.content);
+                if (t) {
+                    textParts.push(t);
+                    out.images.push(...extractMediaMarkers(t));
+                }
+                break;
+            }
             case "thinking": {
                 const t = readString(block.thinking);
                 if (t)

package/index.ts

@@ -30,8 +30,6 @@ const hookLogger = createFridayNextLogger("hook");
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
 
-/** `api.on` returns void — register tool hooks at most once per process. */
-let fridayNextToolHooksRegistered = false;
 let disposeAgentEventListener: (() => void) | null = null;
 /**
  * Track the last `api` instance on which HTTP routes were registered.
@@ -163,10 +161,17 @@ export default defineChannelPluginEntry({
       );
     });
 
-    if (fridayNextToolHooksRegistered) {
+    // Tool hooks (subagent_delivery_target / before_tool_call / after_tool_call) must follow the
+    // SAME re-registration discipline as the HTTP routes and onAgentEvent listener above. When the
+    // health-monitor restarts the plugin, `registerFull` receives a fresh `api` and the host
+    // dispatches hooks on THAT api; hooks left bound to the first api go silent for the rest of the
+    // process. The old one-time boolean guard bound them to whichever api arrived first — which is
+    // exactly why Codex `command_output` (the A3 after_tool_call stdout synthesis) fired on some
+    // gateway processes and not others. Re-register on every genuinely-new api; skip only a repeat
+    // call with the same api (matching the `!sameApi` gate the routes use).
+    if (sameApi) {
       return;
     }
-    fridayNextToolHooksRegistered = true;
 
     // Make Codex (ChatGPT/OAuth) models emit reasoning summary text so the app can stream
     // "thinking". OpenClaw never sets this; we assert it on the plugin side. Best-effort.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/friday-session.forward-agent.test.ts

@@ -195,6 +195,27 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
   });
 
+  it("KEEPS suppressed item kind:command (exec row the command_output stdout attaches to)", () => {
+    // The `tool`-stream exec result is just {exitCode,duration}; the real stdout arrives on the
+    // synthesized `command_output` end event, which the app attaches to the command-terminal row
+    // bootstrapped from THIS `item kind:command`. Dropping it (as the old broad filter did) left
+    // exec tools with a command line and no output in the trace.
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: {
+        itemId: "call_exec1",
+        kind: "command",
+        phase: "start",
+        name: "bash",
+        suppressChannelProgress: true,
+      },
+    });
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+  });
+
   it("forwards item events that are not suppressed (e.g. reasoning analysis markers)", () => {
     forwardAgentEventRaw({
       runId,

package/src/friday-session.ts

@@ -401,12 +401,20 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   // Codex app-server projects every tool/command call onto BOTH the standard `tool` stream
   // (carrying args + the real result) AND a redundant `item` event (kind:"tool"/"command"),
   // and core flags that item `suppressChannelProgress: true` ("do not surface in channel
-  // progress"). Forwarding the suppressed item anyway double-renders every non-exec tool in
-  // the app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing
-  // only on the first. Honor the flag and drop suppressed items; the `tool` stream (and, for
-  // exec, the synthesized `command_output`) already carries everything the app renders. Codex
-  // reasoning items (preamble/analysis) are NOT suppressed, so this never touches thinking.
-  if (evt.stream === "item" && evt.data.suppressChannelProgress === true) {
+  // progress"). Forwarding the suppressed *tool* item double-renders every non-exec tool in the
+  // app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing only
+  // on the first. So drop ONLY suppressed `kind:"tool"` items.
+  //
+  // BUT keep suppressed `kind:"command"`/`"process"` items: the `tool` stream's exec result is
+  // just {exitCode,duration} (no stdout), and the app bootstraps its command-terminal row from
+  // the `item kind:command` event — that row is what the synthesized `command_output` end event
+  // then attaches the real stdout to. Dropping it left exec tools with a command line and no
+  // output in the trace. (Reasoning items preamble/analysis are never suppressed.)
+  if (
+    evt.stream === "item" &&
+    evt.data.suppressChannelProgress === true &&
+    evt.data.kind === "tool"
+  ) {
     return;
   }
 

package/src/history/normalize-message.test.ts

@@ -185,6 +185,33 @@ describe("normalizeHistoryMessage", () => {
     expect(plain?.mediaPaths).toBeUndefined();
   });
 
+  it("extracts Codex exec stdout from a `toolResult`-typed content block", () => {
+    // Codex (app-server) persists bash/exec stdout in a content block whose `type` is
+    // "toolResult" (not "text"); the native path only ever emits "text" blocks. Before the
+    // fix this fell through `default` and the command output was dropped (text="").
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "call_GSu3",
+        toolName: "bash",
+        content: [
+          {
+            type: "toolResult",
+            toolCallId: "call_GSu3",
+            name: "bash",
+            content: "Applications\nDesktop\nDocuments",
+            text: "Applications\nDesktop\nDocuments",
+          },
+        ],
+        ...meta("tr-1", 3),
+      },
+      0,
+    );
+    expect(out?.role).toBe("toolResult");
+    expect(out?.toolResult?.text).toBe("Applications\nDesktop\nDocuments");
+    expect(out?.toolResult?.toolCallId).toBe("call_GSu3");
+  });
+
   it("flags compaction records via __openclaw.kind", () => {
     const out = normalizeHistoryMessage(
       {

package/src/history/normalize-message.ts

@@ -158,6 +158,21 @@ function parseContent(content: unknown): ParsedContent {
         }
         break;
       }
+      case "toolResult":
+      case "tool_result": {
+        // Codex (app-server backend) persists an exec/bash tool's STDOUT in a content
+        // block whose `type` is "toolResult" (not "text") — the output lives in the
+        // block's `text`/`content`. The native/Anthropic path uses plain "text" blocks,
+        // so this case was never hit and the command output was silently dropped from
+        // history (`parsed.text` stayed ""), leaving the app's trace tool row with no
+        // result. ControlUI shows it because its projection reads these blocks.
+        const t = readString(block.text) || readString(block.content);
+        if (t) {
+          textParts.push(t);
+          out.images.push(...extractMediaMarkers(t));
+        }
+        break;
+      }
       case "thinking": {
         const t = readString(block.thinking);
         if (t) thinkingParts.push(t);