@syengup/friday-channel-next 0.1.39 → 1.0.0

package/dist/index.js

@@ -6,12 +6,13 @@ import { getHostOpenClawConfigSnapshot } from "./src/host-config.js";
 import { registerFridayNextHttpRoutes } from "./src/http/server.js";
 import { getFridayNextRuntime } from "./src/runtime.js";
 import { sseEmitter } from "./src/sse/emitter.js";
-import { forwardAgentEventRaw, getLastRegisteredFridayDeviceId, resolveFridayDeviceIdForSessionKey, } from "./src/friday-session.js";
+import { forwardAgentEventRaw, getLastRegisteredFridayDeviceId, isCodexRun, resolveFridayDeviceIdForSessionKey, } from "./src/friday-session.js";
 import { setFridayAgentForwardRuntime } from "./src/agent-forward-runtime.js";
 import { setUpgradeRuntime } from "./src/upgrade-runtime.js";
 import { getOpenClawAgentRunContext } from "./src/agent-run-context-bridge.js";
 import { accumulateRunUsage } from "./src/agent/run-usage-accumulator.js";
 import { createFridayNextLogger } from "./src/logging.js";
+import { ensureCodexReasoningSummary } from "./src/codex-reasoning-config.js";
 const hookLogger = createFridayNextLogger("hook");
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
@@ -50,6 +51,38 @@ function deviceIdFromToolContext(ctx) {
 function isFridaySessionKey(sk) {
     return /^friday-next-/i.test(sk) || /^agent:main:friday-next-/i.test(sk);
 }
+/** Shell/exec-style tools whose stdout the app renders as a `command_output` row (A3). */
+const COMMAND_TOOL_NAMES = new Set([
+    "exec",
+    "bash",
+    "shell",
+    "local_shell",
+    "command",
+    "process",
+    "run_terminal_cmd",
+]);
+function isCommandTool(toolName) {
+    return typeof toolName === "string" && COMMAND_TOOL_NAMES.has(toolName.trim().toLowerCase());
+}
+/** Best-effort flatten of an after-hook tool result into the stdout string the app expects. */
+function coerceCommandOutput(result) {
+    if (typeof result === "string")
+        return result;
+    if (result && typeof result === "object") {
+        const r = result;
+        for (const key of ["output", "stdout", "text"]) {
+            if (typeof r[key] === "string")
+                return r[key];
+        }
+        try {
+            return JSON.stringify(result);
+        }
+        catch {
+            return "";
+        }
+    }
+    return result == null ? "" : String(result);
+}
 function shouldForwardToolEventToFriday(ctx) {
     if (ctx.runId) {
         if (sseEmitter.getDeviceIdByRunId(ctx.runId))
@@ -113,6 +146,9 @@ export default defineChannelPluginEntry({
             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));
         api.on("subagent_delivery_target", (event) => {
             if (!event.expectsCompletionMessage)
                 return;
@@ -189,6 +225,28 @@ export default defineChannelPluginEntry({
                     ts: Date.now(),
                 },
             });
+            // A3: the Codex app-server backend never puts exec stdout on the `command_output` stream
+            // (its tool result carries only exitCode/duration), so the app shows the command row with no
+            // output. The after-hook DOES carry the full stdout — synthesize a `command_output` end event
+            // keyed by toolCallId (== the forwarded `item kind:command` itemId) so the app attaches it.
+            // Codex-only: embedded runs already stream `command_output` on the bus.
+            if (isCodexRun(runId) && event.toolCallId && isCommandTool(event.toolName)) {
+                const output = coerceCommandOutput(event.result);
+                if (output) {
+                    forwardAgentEventRaw({
+                        runId,
+                        stream: "command_output",
+                        data: {
+                            itemId: event.toolCallId,
+                            phase: "end",
+                            output,
+                            status: event.error ? "failed" : "completed",
+                            durationMs: event.durationMs ?? null,
+                        },
+                        sessionKey: ctx.sessionKey,
+                    });
+                }
+            }
         });
     },
 });

package/dist/src/agent/subagent-registry.d.ts

@@ -25,6 +25,10 @@ type SpawnIntent = {
 };
 /** Called by forwardAgentEventRaw on lifecycle start so we can resolve parentRunId. */
 export declare function registerSessionKeyForRun(sessionKey: string, runId: string): void;
+export declare function parseAnnounceRunId(runId: string): {
+    childSessionKey: string;
+    bareRunId: string;
+} | null;
 /** Look up subagent entry by any runId form (announce compound or bare). */
 export declare function lookupByRunId(runId: string): SubagentEntry | undefined;
 /** Look up subagent entry by childSessionKey. */

package/dist/src/agent/subagent-registry.js

@@ -16,7 +16,7 @@ export function registerSessionKeyForRun(sessionKey, runId) {
  *   → { childSessionKey: "agent:main:subagent:uuid", bareRunId: "runId" }
  */
 const ANNOUNCE_RUN_ID_RE = /^announce:v\d+:(agent:.+?):([^:]+)$/;
-function parseAnnounceRunId(runId) {
+export function parseAnnounceRunId(runId) {
     const m = runId.match(ANNOUNCE_RUN_ID_RE);
     if (!m)
         return null;

package/dist/src/approval/friday-approval-capability.d.ts

@@ -0,0 +1,44 @@
+import type { ChannelApprovalCapability } from "openclaw/plugin-sdk/channel-contract";
+/** SSE payload the app receives for an approval lifecycle event. `op` is the phase. */
+export interface FridayApprovalPayload {
+    op: "request" | "resolved" | "expired";
+    approvalId: string;
+    kind: "exec" | "plugin";
+    title: string;
+    description?: string | null;
+    commandText?: string | null;
+    commandPreview?: string | null;
+    cwd?: string | null;
+    host?: string | null;
+    toolName?: string | null;
+    severity?: string | null;
+    metadata: {
+        label: string;
+        value: string;
+    }[];
+    actions: {
+        decision: string;
+        label: string;
+        style: string;
+    }[];
+    expiresAtMs?: number | null;
+    decision?: string | null;
+    resolvedBy?: string | null;
+    sessionKey?: string | null;
+    runId?: string | null;
+    deviceId: string;
+    ts: number;
+}
+/** Build the normalized app payload from a pending/resolved/expired approval view. */
+export declare function buildPayload(params: {
+    op: FridayApprovalPayload["op"];
+    view: Record<string, unknown>;
+    request: unknown;
+    deviceId: string;
+}): FridayApprovalPayload;
+/**
+ * friday-next approval capability. `native` declares delivery to the originating device's session;
+ * `nativeRuntime` builds the app payload and ferries it over SSE. No `delivery` suppressor → additive
+ * with ControlUI.
+ */
+export declare const fridayApprovalCapability: ChannelApprovalCapability;

package/dist/src/approval/friday-approval-capability.js

@@ -0,0 +1,174 @@
+// Friday Next exec/plugin approval capability.
+//
+// Lets the Friday app receive tool-execution approval REQUESTS (e.g. a Codex model wanting to run a
+// shell command that needs confirmation) and submit allow/deny DECISIONS — instead of those
+// approvals only reaching the gateway's built-in ControlUI.
+//
+// Model: unlike Slack (a separate approver list authorized per-account), friday-next uses a
+// device-owner model — the device that owns the originating session is the approver. HTTP requests
+// already carry the channel bearer token, so per-sender authorization happens at the route layer;
+// here we only resolve WHICH device a request belongs to (its session's device) and deliver the
+// prompt there over SSE. The decision round-trips via POST /friday-next/approvals/{id}.
+//
+// We intentionally do NOT set a `delivery.shouldSuppressForwardingFallback` adapter, so enabling
+// this stays additive: ControlUI keeps working as a fallback while the app surface is the primary.
+import { createChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { sseEmitter } from "../sse/emitter.js";
+import { resolveFridayDeviceIdForSessionKey } from "../friday-session.js";
+import { createFridayNextLogger } from "../logging.js";
+const logger = createFridayNextLogger("approval");
+/** Pull the originating sessionKey out of an exec/plugin approval request (`request.request.*`). */
+function sessionKeyOf(request) {
+    const inner = request?.request;
+    const sk = inner?.sessionKey;
+    return typeof sk === "string" && sk.trim() ? sk.trim() : undefined;
+}
+/** Resolve the friday device that owns this approval's session, if any. */
+function deviceForRequest(request) {
+    const sk = sessionKeyOf(request);
+    if (!sk)
+        return undefined;
+    const dev = resolveFridayDeviceIdForSessionKey(sk);
+    return dev ? dev.toUpperCase() : undefined;
+}
+/** Build the normalized app payload from a pending/resolved/expired approval view. */
+export function buildPayload(params) {
+    const { op, view, request, deviceId } = params;
+    const str = (v) => (typeof v === "string" ? v : null);
+    const num = (v) => (typeof v === "number" ? v : null);
+    const actionsRaw = Array.isArray(view.actions) ? view.actions : [];
+    const metaRaw = Array.isArray(view.metadata) ? view.metadata : [];
+    return {
+        op,
+        approvalId: str(view.approvalId) ?? "",
+        kind: view.approvalKind === "plugin" ? "plugin" : "exec",
+        title: str(view.title) ?? "",
+        description: str(view.description),
+        commandText: str(view.commandText),
+        commandPreview: str(view.commandPreview),
+        cwd: str(view.cwd),
+        host: str(view.host),
+        toolName: str(view.toolName),
+        severity: str(view.severity),
+        metadata: metaRaw.map((m) => ({ label: str(m.label) ?? "", value: str(m.value) ?? "" })),
+        actions: actionsRaw.map((a) => ({
+            decision: str(a.decision) ?? "",
+            label: str(a.label) ?? "",
+            style: str(a.style) ?? "secondary",
+        })),
+        expiresAtMs: num(view.expiresAtMs),
+        decision: str(view.decision),
+        resolvedBy: str(view.resolvedBy),
+        sessionKey: sessionKeyOf(request) ?? null,
+        runId: sseEmitter.getLastRunIdForDevice(deviceId),
+        deviceId,
+        ts: Date.now(),
+    };
+}
+function emitApproval(deviceId, payload) {
+    sseEmitter.broadcast({ type: "approval", data: { ...payload } }, deviceId, true);
+}
+const fridayApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+    eventKinds: ["exec", "plugin"],
+    availability: {
+        isConfigured: () => true,
+        shouldHandle: ({ request }) => deviceForRequest(request) !== undefined,
+    },
+    presentation: {
+        buildPendingPayload: ({ request, view }) => {
+            const deviceId = deviceForRequest(request) ?? "";
+            return buildPayload({
+                op: "request",
+                view: view,
+                request,
+                deviceId,
+            });
+        },
+        buildResolvedResult: ({ request, view }) => {
+            const deviceId = deviceForRequest(request) ?? "";
+            return {
+                kind: "update",
+                payload: buildPayload({
+                    op: "resolved",
+                    view: view,
+                    request,
+                    deviceId,
+                }),
+            };
+        },
+        buildExpiredResult: ({ request, view }) => {
+            const deviceId = deviceForRequest(request) ?? "";
+            return {
+                kind: "update",
+                payload: buildPayload({
+                    op: "expired",
+                    view: view,
+                    request,
+                    deviceId,
+                }),
+            };
+        },
+    },
+    transport: {
+        prepareTarget: ({ plannedTarget, request }) => {
+            const planned = typeof plannedTarget?.target?.to === "string" && plannedTarget.target.to.trim()
+                ? plannedTarget.target.to.trim().toUpperCase()
+                : undefined;
+            const deviceId = planned ?? deviceForRequest(request);
+            if (!deviceId)
+                return null;
+            return { dedupeKey: `friday-approval:${deviceId}`, target: { deviceId } };
+        },
+        deliverPending: ({ preparedTarget, pendingPayload }) => {
+            const deviceId = preparedTarget.deviceId;
+            logger.info(`deliver approval ${pendingPayload.approvalId} kind=${pendingPayload.kind} -> ${deviceId}`);
+            emitApproval(deviceId, { ...pendingPayload, deviceId });
+            return { deviceId, approvalId: pendingPayload.approvalId };
+        },
+        updateEntry: async ({ entry, payload }) => {
+            emitApproval(entry.deviceId, { ...payload, deviceId: entry.deviceId });
+        },
+        deleteEntry: async ({ entry, phase }) => {
+            emitApproval(entry.deviceId, {
+                op: phase === "resolved" ? "resolved" : "expired",
+                approvalId: entry.approvalId,
+                kind: "exec",
+                title: "",
+                metadata: [],
+                actions: [],
+                deviceId: entry.deviceId,
+                ts: Date.now(),
+            });
+        },
+    },
+    observe: {
+        onDeliveryError: ({ error }) => {
+            logger.warn(`approval delivery failed: ${String(error)}`);
+        },
+    },
+});
+/**
+ * friday-next approval capability. `native` declares delivery to the originating device's session;
+ * `nativeRuntime` builds the app payload and ferries it over SSE. No `delivery` suppressor → additive
+ * with ControlUI.
+ */
+export const fridayApprovalCapability = {
+    native: {
+        describeDeliveryCapabilities: ({ request }) => {
+            const enabled = deviceForRequest(request) !== undefined;
+            return {
+                enabled,
+                preferredSurface: "origin",
+                supportsOriginSurface: true,
+                supportsApproverDmSurface: false,
+            };
+        },
+        resolveOriginTarget: ({ request }) => {
+            const deviceId = deviceForRequest(request);
+            return deviceId ? { to: deviceId } : null;
+        },
+    },
+    // Cast widens the parameterized adapter to the field's `unknown`-typed shape (function-param
+    // contravariance). Same escape hatch Slack uses for its lazy runtime adapter.
+    nativeRuntime: fridayApprovalNativeRuntime,
+};

package/dist/src/channel.js

@@ -9,6 +9,8 @@ import os from "node:os";
 import path from "node:path";
 import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
 import { waitUntilAbort } from "openclaw/plugin-sdk/channel-lifecycle";
+import { registerChannelRuntimeContext } from "openclaw/plugin-sdk/channel-runtime-context";
+import { CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY } from "openclaw/plugin-sdk/approval-handler-adapter-runtime";
 import { createFridayNextLogger } from "./logging.js";
 import { saveMediaBuffer } from "openclaw/plugin-sdk/media-store";
 import { sseEmitter } from "./sse/emitter.js";
@@ -19,6 +21,7 @@ import { resolveMediaMaxBytes } from "./agent/media-bridge.js";
 import { resolveFridayDeviceIdForOutbound, resolveHistorySessionKeyForFridayDevice, } from "./friday-session.js";
 import { getRunRoute } from "./run-metadata.js";
 import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
+import { fridayApprovalCapability } from "./approval/friday-approval-capability.js";
 const logger = createFridayNextLogger("channel");
 const CHANNEL_ID = "friday-next";
 function pickFirstString(source, keys) {
@@ -97,6 +100,21 @@ const fridayLifecycle = {
  */
 const fridayGateway = {
     startAccount: async (ctx) => {
+        // Activate exec/plugin approval delivery to the app. The gateway's approval-handler bootstrap
+        // only wires up our `approvalCapability` once the channel registers an "approval.native" runtime
+        // context (the registration event is the gate — without it approvals silently skip friday-next
+        // and only reach ControlUI). friday-next's nativeRuntime needs no per-account state — it resolves
+        // the target device from each request's sessionKey via global singletons — so context is empty.
+        if (ctx.channelRuntime) {
+            registerChannelRuntimeContext({
+                channelRuntime: ctx.channelRuntime,
+                channelId: CHANNEL_ID,
+                accountId: ctx.accountId,
+                capability: CHANNEL_APPROVAL_NATIVE_RUNTIME_CONTEXT_CAPABILITY,
+                context: {},
+                abortSignal: ctx.abortSignal,
+            });
+        }
         await waitUntilAbort(ctx.abortSignal);
     },
 };
@@ -297,3 +315,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
         },
     },
 });
+// Attach exec/plugin approval delivery to the app. `createChatChannelPlugin` has no config slot for
+// it, so it's set on the returned plugin object; setting it auto-registers the native approval
+// handler via the gateway's approval bootstrap. Additive with ControlUI (no forwarding suppressor).
+fridayNextChannelPlugin.approvalCapability = fridayApprovalCapability;

package/dist/src/codex-reasoning-config.d.ts

@@ -0,0 +1,11 @@
+/**
+ * True if a top-level `model_reasoning_summary` key already exists. TOML scoping matters: a key is
+ * only top-level (and thus honored by Codex) if it appears before the first `[section]` header, so
+ * we stop scanning at the first table header.
+ */
+export declare function hasTopLevelSummaryKey(content: string): boolean;
+/**
+ * Best-effort: ensure every agent's Codex config requests a reasoning summary. Never throws —
+ * activation must not fail because of a config write. `log` receives a one-line summary per change.
+ */
+export declare function ensureCodexReasoningSummary(log: (msg: string) => void): void;

package/dist/src/codex-reasoning-config.js

@@ -0,0 +1,83 @@
+// Ensures the Codex app-server backend emits reasoning *summary* text so Friday can stream it.
+//
+// Background: OpenAI models authenticated via ChatGPT/OAuth run through OpenClaw's Codex
+// app-server backend. That backend sends `reasoning_effort` per turn but never requests a
+// reasoning summary, and OpenClaw exposes no `openclaw.json` lever for it. Without a summary the
+// model's reasoning stays encrypted (`encrypted_content`) and no reasoning text reaches the
+// channel — so the Friday app shows no streaming "thinking" for Codex models.
+//
+// The only switch that makes Codex return summary text is the Codex CLI's own
+// `model_reasoning_summary` key in `~/.openclaw/agents/<id>/agent/codex-home/config.toml`.
+// We keep the fix on the plugin side by asserting that key on activation (idempotently, for every
+// agent that has a codex-home), so it survives OpenClaw rewrites of that file across restarts.
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CONFIG_KEY = "model_reasoning_summary";
+// "detailed" is the value verified end-to-end (reasoning streamed to the app). Codex also accepts
+// "auto"/"concise"; tune here if the summaries feel too verbose.
+const SUMMARY_VALUE = "detailed";
+function resolveOpenClawHome() {
+    const env = process.env.OPENCLAW_HOME?.trim();
+    return env && env.length > 0 ? env : join(homedir(), ".openclaw");
+}
+/**
+ * True if a top-level `model_reasoning_summary` key already exists. TOML scoping matters: a key is
+ * only top-level (and thus honored by Codex) if it appears before the first `[section]` header, so
+ * we stop scanning at the first table header.
+ */
+export function hasTopLevelSummaryKey(content) {
+    for (const raw of content.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (line.startsWith("["))
+            break;
+        if (new RegExp(`^${CONFIG_KEY}\\s*=`).test(line))
+            return true;
+    }
+    return false;
+}
+function ensureKeyInCodexHome(codexHome) {
+    const configPath = join(codexHome, "config.toml");
+    const header = `${CONFIG_KEY} = "${SUMMARY_VALUE}"\n`;
+    if (!existsSync(configPath)) {
+        writeFileSync(configPath, header, "utf8");
+        return "added";
+    }
+    const content = readFileSync(configPath, "utf8");
+    if (hasTopLevelSummaryKey(content))
+        return "present";
+    // Prepend so the key stays top-level even if the file starts with a `[section]` table.
+    writeFileSync(configPath, `${header}\n${content}`, "utf8");
+    return "added";
+}
+/**
+ * Best-effort: ensure every agent's Codex config requests a reasoning summary. Never throws —
+ * activation must not fail because of a config write. `log` receives a one-line summary per change.
+ */
+export function ensureCodexReasoningSummary(log) {
+    try {
+        const agentsDir = join(resolveOpenClawHome(), "agents");
+        if (!existsSync(agentsDir))
+            return;
+        for (const agentId of readdirSync(agentsDir)) {
+            const codexHome = join(agentsDir, agentId, "agent", "codex-home");
+            // Only touch agents Codex has actually initialized (codex-home exists). New agents are
+            // picked up on the next activation/restart.
+            if (!existsSync(codexHome))
+                continue;
+            try {
+                mkdirSync(codexHome, { recursive: true });
+                const result = ensureKeyInCodexHome(codexHome);
+                if (result === "added") {
+                    log(`codex reasoning summary enabled (agent=${agentId})`);
+                }
+            }
+            catch (err) {
+                log(`codex reasoning summary write failed (agent=${agentId}): ${String(err)}`);
+            }
+        }
+    }
+    catch (err) {
+        log(`codex reasoning summary ensure failed: ${String(err)}`);
+    }
+}

package/dist/src/friday-session.d.ts

@@ -1,5 +1,9 @@
 /** Vitest-only: clears per-run reasoning text cache used for incremental `delta` rewriting. */
 export declare function resetThinkingStreamAccumStateForTest(): void;
+/** True once a `codex_app_server.*` frame has been seen for this run. */
+export declare function isCodexRun(runId: string): boolean;
+/** Vitest-only */
+export declare function resetCodexRunTrackingForTest(): void;
 /** Vitest-only */
 export declare function resetOpenClawRunDeviceMappingForTest(): void;
 /** Parse deviceId from a Friday Next channel sessionKey (friday-{deviceId} or legacy agent:main:friday-*). */

package/dist/src/friday-session.js

@@ -6,7 +6,7 @@ import { observeAgentEventForActiveRuns } from "./agent/active-runs.js";
 import { getRunMetadata, ingestAgentEventMetadata } from "./run-metadata.js";
 import { consumeRunUsage } from "./agent/run-usage-accumulator.js";
 import { readSessionUsageSnapshotFromStore } from "./session-usage-store.js";
-import { lookupByRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
+import { lookupByRunId, lookupByChildSessionKey, parseAnnounceRunId, registerSessionKeyForRun, registerSpawnIntent, consumeSpawnIntent, ensureSubagentFromSpawnTool, registerEnded as registerSubagentEnded, } from "./agent/subagent-registry.js";
 /** Last `data.text` per run for `stream: "thinking"` — OpenClaw core may send cumulative `delta`; we rewrite true increments for the app. */
 const lastThinkingTextByRun = new Map();
 function commonPrefixLength(a, b) {
@@ -20,6 +20,24 @@ function commonPrefixLength(a, b) {
 export function resetThinkingStreamAccumStateForTest() {
     lastThinkingTextByRun.clear();
 }
+/**
+ * Runs backed by the OpenClaw Codex app-server backend (model api `openai-chatgpt-responses`).
+ * They emit their activity under a `codex_app_server.*` stream namespace and — unlike the embedded
+ * runner — do NOT put reasoning text on the agent-event bus (`stream: "thinking"`); that text only
+ * arrives via the dispatch `onReasoningStream` callback. Likewise exec stdout never reaches the
+ * `command_output` stream. We mark a run as Codex the first time we see any `codex_app_server.*`
+ * frame so the message handler / tool hooks know to synthesize the missing `thinking` /
+ * `command_output` events for it (and ONLY for it — embedded runs already get both via the bus).
+ */
+const codexRunIds = new Set();
+/** True once a `codex_app_server.*` frame has been seen for this run. */
+export function isCodexRun(runId) {
+    return codexRunIds.has(runId);
+}
+/** Vitest-only */
+export function resetCodexRunTrackingForTest() {
+    codexRunIds.clear();
+}
 /**
  * OpenClaw `runId` → device UUID (uppercase).
  * When `lifecycle.end` / `error` is emitted, the gateway may call `clearAgentRunContext` before this extension's
@@ -298,6 +316,11 @@ export function forwardAgentEventRaw(evt) {
         sk = latestHistorySessionKeyForDeviceId(deviceIdRaw) ?? `friday-next-${deviceIdRaw}`;
     }
     openClawRunIdToDeviceId.set(evt.runId, deviceIdRaw.toUpperCase());
+    // Flag Codex app-server runs so the message handler / tool hooks synthesize the `thinking` /
+    // `command_output` events that this backend never emits on the bus (see `isCodexRun`).
+    if (typeof evt.stream === "string" && evt.stream.startsWith("codex_app_server")) {
+        codexRunIds.add(evt.runId);
+    }
     // Register sessionKey → runId so we can resolve parentRunId
     if (sk && evt.stream === "lifecycle" && evt.data.phase === "start") {
         registerSessionKeyForRun(sk, evt.runId);
@@ -323,6 +346,10 @@ export function forwardAgentEventRaw(evt) {
                     phase: "spawning",
                     childSessionKey: null,
                     runId: null,
+                    // A2: the spawn tool-call id is the only stable correlation key before the
+                    // gateway assigns childSessionKey/runId — the app mints the placeholder window
+                    // under it, then rekeys to childSessionKey on spawned.
+                    toolCallId,
                     label: intent.label ?? null,
                     parentRunId: intent.parentRunId,
                     depth: intent.depth,
@@ -357,6 +384,9 @@ export function forwardAgentEventRaw(evt) {
                     phase: "spawned",
                     runId: compoundRunId,
                     childSessionKey: entry.childSessionKey,
+                    // A2: echo the spawn toolCallId so the app deterministically links this
+                    // spawned event to the placeholder window it minted at spawning time.
+                    toolCallId: toolCallId || null,
                     label: entry.label ?? null,
                     parentRunId: entry.parentRunId ?? null,
                     depth: entry.depth,
@@ -365,6 +395,28 @@ export function forwardAgentEventRaw(evt) {
             }, entry.deviceId);
         }
     }
+    // Phase 3 (A3): announce-summary delivery to the parent. OpenClaw emits the parent's
+    // `lifecycle.start` under the announce compound runId once a subagent's result is being
+    // folded back in. We parse the authoritative childSessionKey here (the registry already
+    // knows how) and broadcast an explicit `dismissed` subagent event, so the app removes the
+    // settled window by childSessionKey instead of re-parsing the announce runId itself.
+    if (evt.stream === "lifecycle" && evt.data.phase === "start") {
+        const announced = parseAnnounceRunId(evt.runId);
+        if (announced) {
+            const entry = lookupByChildSessionKey(announced.childSessionKey) ?? lookupByRunId(evt.runId);
+            sseEmitter.broadcast({
+                type: "subagent",
+                data: {
+                    phase: "dismissed",
+                    childSessionKey: entry?.childSessionKey ?? announced.childSessionKey,
+                    runId: entry?.runId ?? announced.bareRunId ?? null,
+                    parentRunId: entry?.parentRunId ?? null,
+                    depth: entry?.depth ?? 1,
+                    deviceId: deviceIdRaw,
+                },
+            }, deviceIdRaw);
+        }
+    }
     const subagentEntry = lookupByRunId(evt.runId);
     // Only annotate events that originate from the subagent itself
     // (sessionKey matches childSessionKey). Main-agent delivery events
@@ -375,6 +427,11 @@ export function forwardAgentEventRaw(evt) {
             label: subagentEntry.label,
             parentRunId: subagentEntry.parentRunId,
             depth: subagentEntry.depth,
+            // A1: ship the authoritative childSessionKey + lifecycle status on every
+            // subagent agent-delta so the app routes/identifies by stable keys instead of
+            // guessing from runId.
+            childSessionKey: subagentEntry.childSessionKey,
+            status: subagentEntry.status,
         }
         : undefined;
     let outgoingData = { ...evt.data };
@@ -398,6 +455,7 @@ export function forwardAgentEventRaw(evt) {
         }
         if (phase === "end" || phase === "error") {
             lastThinkingTextByRun.delete(evt.runId);
+            codexRunIds.delete(evt.runId);
         }
     }
     const lifecyclePhase = evt.stream === "lifecycle" && typeof evt.data.phase === "string" ? evt.data.phase : "";

package/dist/src/http/handlers/agents-list.js

@@ -82,8 +82,12 @@ function resolveConfiguredAgents() {
     const agents = cfg?.agents;
     const list = agents?.list;
     if (!Array.isArray(list) || list.length === 0) {
+        // Implicit `main` agent (no `agents.list`): config carries no name, so fall
+        // back to the workspace IDENTITY.md `Name` — the same source ControlUI and
+        // the list branch below use — instead of letting the app show the raw id.
+        const name = readWorkspaceIdentityName(rt, cfg, DEFAULT_AGENT_ID);
         return {
-            agents: [{ id: DEFAULT_AGENT_ID, isDefault: true }],
+            agents: [{ id: DEFAULT_AGENT_ID, isDefault: true, ...(name ? { name } : {}) }],
             defaultAgentId: DEFAULT_AGENT_ID,
         };
     }

package/dist/src/http/handlers/approvals.d.ts

@@ -0,0 +1,9 @@
+import type { IncomingMessage, ServerResponse } from "node:http";
+/**
+ * POST /friday-next/approvals/{approvalId}
+ * Body: { decision: "allow-once" | "allow-always" | "deny", deviceId?: string }
+ *
+ * Submits the app user's decision for a pending exec/plugin approval back to the gateway. The bearer
+ * token gates auth (the device owner is the approver); the gateway then resumes / aborts the run.
+ */
+export declare function handleApprovalDecision(req: IncomingMessage, res: ServerResponse, approvalId: string): Promise<boolean>;