@agentprojectcontext/apx 1.80.2 → 1.89.1

package/src/host/daemon/api/super-agent.js

@@ -6,20 +6,29 @@
 //   POST /projects/:pid/super-agent/chat/stream    NDJSON event stream
 //   POST /projects/:pid/super-agent/chat            blocking JSON response
 import { runSuperAgent } from "#core/agent/super-agent.js";
-import {
-  resolveSuperAgentContext,
-  appendSuperAgentErrorTrace,
-} from "./shared.js";
+import { resolveSuperAgentContext,
+  appendSuperAgentErrorTrace, asyncRoute } from "./shared.js";
 import { loggerFor } from "#core/logging.js";
 import { appendGlobalMessage } from "#core/stores/messages.js";
+import { summarizeToolTrace } from "#core/agent/tool-summary.js";
+import { floorReplyText } from "#core/agent/closing-floor.js";
+import { SUPERAGENT_ACTOR_ID } from "#core/identity/index.js";
 import { createWebConfirmAdapter } from "#core/confirmation/adapters/web.js";
 import { tryResolveSkillCommand } from "#core/agent/skills/trigger.js";
 import { suggestSkillForPrompt } from "#core/agent/skills/rag.js";
 import { inspectPromptForSkills, isInspectorEnabled, summarizeTrace } from "#core/agent/skills/inspector.js";
 import { CHANNELS } from "#core/constants/channels.js";
+import { readTurnAttachments } from "./media.js";
+import { startActiveTurn, appendActiveTurn, recordActiveTurnEvent, endActiveTurn, superAgentTurnKey } from "../active-turns.js";
+import { broadcastTurn } from "../events-ws.js";
+import { wasAborted, abortedTurnEvent } from "./turn-abort.js";
 
 const log = loggerFor("super-agent");
 
+// How long a streamed turn may go silent before it writes a keepalive byte.
+// Comfortably under undici's 300s body timeout and the usual proxy idle limits.
+const KEEPALIVE_MS = 20_000;
+
 // Emit a single, readable line so `apx log -f` shows exactly what the skill
 // inspector decided this turn (which skills it loaded/hinted, the embedder, and
 // the top similarity). Best-effort: logging must never break a reply.
@@ -39,38 +48,187 @@ function logInspectorDecision(trace, { trace_id, channel } = {}) {
   }
 }
 
+// What of the inspector trace is worth keeping on disk: the decision, not the
+// payload. `null` only when the inspector had nothing to say at all — no skill
+// injected AND no candidate scored. When it scored candidates but none crossed
+// the load/hint bar we STILL keep the row: a reopened thread should be able to
+// show what was suggested each round (the "considered" near-misses), which is
+// what makes the per-turn RAG legible instead of silently doing nothing.
+export function inspectorRecord(trace) {
+  if (!trace?.enabled) return null;
+  const loaded = trace.loaded || [];
+  const hinted = trace.hinted || [];
+  const scored = trace.scored || [];
+  if (loaded.length === 0 && hinted.length === 0 && scored.length === 0) return null;
+  return {
+    ...(trace.embedder ? { embedder: trace.embedder } : {}),
+    ...(loaded.length ? { loaded } : {}),
+    ...(hinted.length ? { hinted } : {}),
+    // Already capped at the top 5 upstream — the similarities the badge shows,
+    // and the source of the dim "considered" badges when nothing was injected.
+    ...(scored.length ? { scored } : {}),
+  };
+}
+
 // Persist human web turns to the cross-channel message store so they feed the
-// RAG index, search_messages, and the "active threads" awareness block. Only
-// the human surfaces (web big chat + sidebar) — not generic "api"/automation
-// callers. Best-effort: a logging failure never breaks the reply.
-const WEB_LOGGED_CHANNELS = new Set([CHANNELS.WEB, CHANNELS.WEB_SIDEBAR]);
-function logWebTurn(channel, { prompt, replyText, name, model, usage }) {
-  if (!WEB_LOGGED_CHANNELS.has(channel)) return;
+// RAG index, search_messages, and the "active threads" awareness block.
+//
+// This used to keep only web + web_sidebar, on the reasoning that everything
+// else was "automation". That was wrong once real people started arriving over
+// those channels: a WhatsApp contact writing to the bridge, or an agent relay,
+// produced a turn that was answered and then vanished — no thread, no history,
+// nothing in the inbox, and no way to tell a working bridge from a dead one.
+//
+// So the rule inverts: a conversation is written unless it is machine chatter.
+// A routine's output already travels its own delivery path and lands in the
+// agent's chat; writing it here too would double it and bury the inbox.
+//
+// Consequence worth naming: message text from third parties (WhatsApp) now
+// enters the ledger, which is what feeds RAG and the awareness block. That is
+// the price of the conversation being visible at all, and the owner chose it.
+// Best-effort: a logging failure never breaks the reply.
+const LEDGER_SKIP_CHANNELS = new Set([CHANNELS.ROUTINE]);
+
+/** Which project the chat was opened from. The ledger is one file per
+ *  channel+day for the whole daemon, so without this stamp a chat started
+ *  inside a project could only be found in the Base workspace — from the
+ *  project it was started in, it looked gone. */
+const ledgerScope = (project) =>
+  project ? { project_id: String(project.id), project_name: project.name } : {};
+
+/**
+ * The INBOUND half, written the moment the request arrives.
+ *
+ * It used to be written with the reply, when the turn was over. A WhatsApp
+ * round drives a phone for three minutes, and for those three minutes nothing
+ * anywhere showed that a message had arrived at all — the panel open on that
+ * thread stayed blank until the whole turn landed, and a turn that crashed took
+ * the record of the message with it. What arrived is a fact as soon as it
+ * arrives; what the agent answers is a separate one.
+ *
+ * Best-effort: a logging failure never breaks the turn.
+ */
+function logInboundTurn(channel, { prompt, project, media }) {
+  if (!channel || LEDGER_SKIP_CHANNELS.has(channel)) return;
   try {
-    appendGlobalMessage({ channel, direction: "in", type: "user", author: "user", body: prompt });
-    if (replyText) {
-      // Attribution rides along on the record: which model answered and what the
-      // turn cost. Without it a reloaded thread renders "0 tok" and no model.
-      appendGlobalMessage({
-        channel,
-        direction: "out",
-        type: "agent",
-        author: name || undefined,
-        body: replyText,
-        meta: { ...(model ? { model } : {}), ...(usage ? { usage } : {}) },
-      });
+    appendGlobalMessage({
+      channel, direction: "in", type: "user", author: "user", body: prompt,
+      // `media` records the file the turn was sent with (local_path, name, mime
+      // — see readTurnAttachments), which is what lets a reopened thread render
+      // the photo instead of the marker text the agent was handed.
+      meta: { ...ledgerScope(project), ...(media || {}) },
+    });
+  } catch { /* the ledger is a record, not a dependency */ }
+}
+
+export function logWebTurn(channel, { replyText, name, model, usage, trace, project, inspector, reasoning, timeline = [] }) {
+  if (!channel || LEDGER_SKIP_CHANNELS.has(channel)) return;
+  const scope = ledgerScope(project);
+  try {
+    // Keep the stream's real order. Before this, live prose preceding a tool
+    // only existed in the browser; a refresh lost it, then the final-only ledger
+    // made the user think APX had erased part of the answer. Fall back to the
+    // old trace-first shape for blocking callers that have no event timeline.
+    const ordered = timeline.length
+      ? [...timeline]
+      : (Array.isArray(trace) ? trace.filter((item) => item?.tool).map((item) => ({ kind: "tool", trace: item })) : []);
+    const exactFinal = String(replyText || "").trim();
+    let finalTextIndex = -1;
+    if (exactFinal) {
+      for (let i = ordered.length - 1; i >= 0; i--) {
+        if (ordered[i]?.kind === "text" && String(ordered[i].text || "").trim() === exactFinal) {
+          finalTextIndex = i;
+          break;
+        }
+      }
+      if (finalTextIndex < 0) {
+        ordered.push({ kind: "text", text: replyText });
+        finalTextIndex = ordered.length - 1;
+      }
+    }
+    const toolSummary = summarizeToolTrace(trace);
+    const skillInspector = inspectorRecord(inspector);
+    for (let index = 0; index < ordered.length; index++) {
+      const item = ordered[index];
+      if (item?.kind === "tool" && item.trace?.tool) {
+        const tool = item.trace;
+        appendGlobalMessage({
+          channel,
+          direction: "out",
+          type: "tool",
+          actor_id: tool.tool,
+          actor_kind: "tool",
+          author: name || undefined,
+          body: `${tool.tool}(${JSON.stringify(tool.args || {}).slice(0, 200)})`,
+          meta: { ...scope, tool: tool.tool, args: tool.args, result: tool.result },
+        });
+      } else if (item?.kind === "text" && item.text) {
+        const isFinal = index === finalTextIndex;
+        appendGlobalMessage({
+          channel,
+          direction: "out",
+          type: "agent",
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          agent_slug: SUPERAGENT_ACTOR_ID,
+          author: name || undefined,
+          body: item.text,
+          meta: {
+            ...scope,
+            // Intermediate prose stays visible after a reopen but never becomes
+            // prompt history for the next turn; it is progress, not the answer.
+            ...(!isFinal ? { streamed: true } : {}),
+            ...(isFinal && model ? { model } : {}),
+            ...(isFinal && usage ? { usage } : {}),
+            ...(isFinal && toolSummary ? { tool_summary: toolSummary } : {}),
+            ...(isFinal && skillInspector ? { skill_inspector: skillInspector } : {}),
+            ...(isFinal && reasoning?.length ? { reasoning } : {}),
+          },
+        });
+      }
     }
   } catch {
     /* best-effort */
   }
 }
 
+/**
+ * One line when a turn had to be closed by the floor. Worth a log even when the
+ * model wrote the closing: the turn itself came back empty after runAgent's
+ * retries, which is a model-chain problem the owner should be able to see. When
+ * the canned line spoke too, TWO calls in a row returned nothing — that is
+ * almost always an engine that is down.
+ */
+function logFlooredTurn({ authored }, { trace_id, channel }) {
+  const how = authored ? "the model wrote the closing" : "the canned floor spoke — the model could not write it either";
+  log.warn(`empty turn closed by the floor: ${how}`, { trace_id, channel });
+}
+
+// A turn's thinking goes on the record, but the ledger is a day-file the whole
+// daemon shares: an agent that loops twenty times must not write a novel into
+// it. One segment per model pass, both ends bounded.
+const REASONING_SEGMENT_CAP = 4000;
+const REASONING_MAX_SEGMENTS = 10;
+
 // Wrap an onEvent emitter so that operationally interesting events also land
 // in the unified daemon log. We don't log every "model_start" — too noisy —
 // just the ones a user would want to see in `apx log -f` after a turn fails
 // or rotates models.
-function wrapOnEventForLog(send, { trace_id, channel }) {
+function wrapOnEventForLog(send, { trace_id, channel, reasoning }) {
   return (event) => {
+    // The thinking, kept for the record. It rides its own event and never the
+    // answer text, so this is the only place it can be picked up before it is
+    // gone — same problem the tool trace has, same fix.
+    if (event?.type === "assistant_reasoning" && Array.isArray(reasoning)) {
+      const piece = String(event.reasoning || "").trim();
+      if (piece && reasoning.length < REASONING_MAX_SEGMENTS) {
+        reasoning.push(
+          piece.length > REASONING_SEGMENT_CAP
+            ? piece.slice(0, REASONING_SEGMENT_CAP) + "…"
+            : piece,
+        );
+      }
+    }
     if (event?.type === "engine_failed") {
       log.warn(
         `engine ${event.model || "?"} failed → retrying with ${event.retry_with || "?"}`,
@@ -92,7 +250,7 @@ function wrapOnEventForLog(send, { trace_id, channel }) {
 }
 
 export function register(api, { projects, registries, plugins, project, config }) {
-  api.post("/projects/:pid/super-agent/chat/stream", async (req, res) => {
+  api.post("/projects/:pid/super-agent/chat/stream", asyncRoute(async (req, res) => {
     const p = project(req, res);
     if (!p) return;
     // Optional coding-surface knobs: the terminal Code TUI (apx code, Build
@@ -100,14 +258,20 @@ export function register(api, { projects, registries, plugins, project, config }
     // module. Plain chat callers omit them and keep the lightweight defaults.
     const { prompt: rawPrompt, previousMessages, model, maxIters, maxTokens, completionContract } =
       req.body || {};
-    if (!rawPrompt) return res.status(400).json({ error: "prompt required" });
+    // Files the composer uploaded to ~/.apx/media and named on this turn. A
+    // photo with no caption IS a turn: the marker built below stands in for the
+    // text, exactly as it does when the same photo arrives over Telegram.
+    const turnFiles = readTurnAttachments(req.body?.attachments);
+    if (!rawPrompt && !turnFiles.markers.length) {
+      return res.status(400).json({ error: "prompt required" });
+    }
     const ctx = resolveSuperAgentContext(req, p);
 
     // `/slug ...` shortcut: load the matching skill body into contextNote and
     // strip the prefix from the user prompt. Falls through unchanged when the
     // slug is unknown.
-    const slashed = tryResolveSkillCommand(rawPrompt, { projectPath: p.path });
-    const prompt = slashed.handled ? slashed.prompt : rawPrompt;
+    const slashed = tryResolveSkillCommand(rawPrompt || "", { projectPath: p.path });
+    const prompt = slashed.handled ? slashed.prompt : rawPrompt || "";
     const inspectorOn = isInspectorEnabled(config);
     let inspectorTrace = null;
     if (slashed.handled) {
@@ -126,24 +290,100 @@ export function register(api, { projects, registries, plugins, project, config }
         ctx.contextNote = [ctx.contextNote, out.contextNote].filter(Boolean).join("\n\n");
       }
     } else {
-      // Legacy path — passive nudge, still works when inspector is off.
+      // Inspector off — fall back to the passive nudge.
       const hint = await suggestSkillForPrompt(prompt, { projectPath: p.path });
       if (hint) ctx.contextNote = [ctx.contextNote, hint].filter(Boolean).join("\n\n");
     }
 
+    // What the model reads, and what the ledger stores: the attachment markers
+    // first, then whatever was typed. The markers are built on this side so the
+    // path they name is one the daemon resolved, not one a client claimed.
+    const turnPrompt = [...turnFiles.markers, prompt].filter(Boolean).join(" ");
+
+    // Before a single token: the message exists now, and the panel (and the
+    // inbox, and the live feed) should say so while the turn is still working.
+    logInboundTurn(ctx.channel, { prompt: turnPrompt, project: p, media: turnFiles.media });
+
     res.setHeader("content-type", "application/x-ndjson; charset=utf-8");
     res.setHeader("cache-control", "no-cache, no-transform");
     res.setHeader("x-accel-buffering", "no");
     res.flushHeaders?.();
 
     const send = (event) => {
+      lastWriteAt = Date.now();
       res.write(JSON.stringify(event) + "\n");
     };
 
-    const onEvent = wrapOnEventForLog(send, {
+    // Keepalive. A turn only writes when something happens, and one tool can own
+    // the turn for minutes on end — run_routine blocks until the routine ends,
+    // by design. To an HTTP client that is an idle response body, and undici
+    // (the CLI, the TUI) drops it at its body timeout with UND_ERR_BODY_TIMEOUT;
+    // proxies in front of the daemon do the same. A bare newline is a valid
+    // no-op in NDJSON — every reader here skips blank lines — so it holds the
+    // connection open without inventing an event type clients must know about.
+    let lastWriteAt = Date.now();
+    const keepalive = setInterval(() => {
+      if (Date.now() - lastWriteAt < KEEPALIVE_MS) return;
+      lastWriteAt = Date.now();
+      try { res.write("\n"); } catch { /* the socket is gone; the finally clears us */ }
+    }, KEEPALIVE_MS);
+    keepalive.unref?.();
+    res.on("close", () => clearInterval(keepalive));
+
+    const reasoning = [];
+    // The run's kill switch, plus the registry entry that lets any surface find
+    // it. Roby's web chat has no conversation id — its thread IS the channel —
+    // so one live turn per project+channel, exactly as Telegram keys one live
+    // turn per chat_id. POST .../turns/abort reaches `abort` through this.
+    const turnAbort = new AbortController();
+    const turnKey = superAgentTurnKey(p.id, ctx.channel);
+    const threadId = new Date().toISOString().slice(0, 10);
+    const active = startActiveTurn(turnKey, {
+      project_id: p.id, channel: ctx.channel, thread_id: threadId, model: model || null,
+      abort: () => turnAbort.abort(),
+    });
+    const turnFrame = (phase, extra = {}) => broadcastTurn({
+      phase,
+      project_id: p.id,
+      agent_slug: null,
+      conversation_id: null,
+      channel: ctx.channel,
+      thread_id: threadId,
+      turn_id: active.id,
+      ...extra,
+    });
+    // The steps as they happen. runSuperAgent throws on abort and its trace goes
+    // with it, so an interrupted turn would otherwise land in the ledger as
+    // prose with the work erased — and the turn that continues it would not know
+    // which tools had already run for real.
+    const partialTrace = [];
+    const timeline = [];
+    const logged = wrapOnEventForLog(send, {
       trace_id: req.apxTraceId,
       channel: ctx.channel,
+      reasoning,
     });
+    // The last thing the turn actually said. The result object does not carry
+    // it — `text` is the CLOSING — and it is the one piece of context a floored
+    // closing needs to not repeat itself. See core/agent/closing-floor.js.
+    let lastSaid = "";
+    const onEvent = (ev) => {
+      recordActiveTurnEvent(active.id, ev);
+      if (ev?.type === "assistant_text" && ev.text) {
+        timeline.push({ kind: "text", text: ev.text });
+        if (String(ev.text).trim()) lastSaid = String(ev.text).trim();
+      }
+      if (ev?.type === "tool_result" && ev.trace) {
+        partialTrace.push(ev.trace);
+        timeline.push({ kind: "tool", trace: ev.trace });
+      }
+      return logged(ev);
+    };
+
+    // The turn's identity, up front, so a client can stop it (POST
+    // .../turns/abort takes the channel for Roby — its thread IS the channel).
+    turnFrame("start");
+    send({ type: "start", turn_id: active.id, channel: ctx.channel, thread_id: threadId });
 
     // Surface the inspector decision to clients before model_start so the web
     // debug panel / TUI can render "loaded: X" the moment the turn begins.
@@ -168,7 +408,10 @@ export function register(api, { projects, registries, plugins, project, config }
         projects,
         plugins,
         registries,
-        prompt,
+        prompt: turnPrompt,
+        // Images ride on this turn's user message; every other kind is already
+        // named, with its path, in the marker.
+        attachments: turnFiles.attachments,
         channel: ctx.channel,
         channelMeta: ctx.channelMeta,
         contextNote: ctx.contextNote,
@@ -178,31 +421,87 @@ export function register(api, { projects, registries, plugins, project, config }
         ...(Number.isFinite(Number(maxTokens)) ? { maxTokens: Number(maxTokens) } : {}),
         ...(completionContract ? { completionContract: true } : {}),
         onEvent,
+        signal: turnAbort.signal,
+        // Token-by-token text. `assistant_text` still closes each segment with
+        // the cleaned version, so a client that ignores deltas (apx exec) reads
+        // exactly what it read before — it just reads it later.
+        onToken: (chunk) => {
+          send({ type: "assistant_delta", delta: chunk });
+          appendActiveTurn(active.id, chunk);
+          turnFrame("delta", { delta: chunk });
+        },
+        // The thinking, live and on its own channel. Clients that don't render
+        // it drop it; the answer never carries a word of it either way.
+        onReasoningToken: (chunk) => send({ type: "assistant_reasoning_delta", reasoning: chunk }),
         requestConfirmation,
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
+      // Never-silent floor. runAgent already re-prompted a dud turn and gave
+      // up; without this the panel renders an empty bubble and the ledger keeps
+      // an empty assistant row — which is what the NEXT turn reads back as the
+      // answer it gave. A real reply passes through untouched and costs nothing.
+      const closing = await floorReplyText({
+        globalConfig: config,
+        text: saResult.text,
+        streamedText: lastSaid,
+        trace: saResult.trace,
+      });
+      if (closing.floored) logFlooredTurn(closing, { trace_id: req.apxTraceId, channel: ctx.channel });
       logWebTurn(ctx.channel, {
-        prompt,
-        replyText: saResult.text,
+        replyText: closing.text,
         name: saResult.name,
         model: saResult.model,
         usage: saResult.usage,
+        trace: saResult.trace,
+        project: p,
+        inspector: inspectorTrace,
+        reasoning,
+        timeline,
       });
+      const finalResult = {
+        text: closing.text,
+        usage: saResult.usage,
+        // `name` is the agent persona; `model` is the engine that answered
+        // (it can differ from the configured one after a routing fallback).
+        name: saResult.name,
+        model: saResult.model,
+        trace: saResult.trace,
+      };
+      turnFrame("final", { result: finalResult });
       send({
         type: "final",
-        result: {
-          text: saResult.text,
-          usage: saResult.usage,
-          // `name` is the agent persona; `model` is the engine that answered
-          // (it can differ from the configured one after a routing fallback).
-          name: saResult.name,
-          model: saResult.model,
-          trace: saResult.trace,
-        },
+        result: finalResult,
       });
+      clearInterval(keepalive);
       res.end();
     } catch (e) {
+      // Interrupted, not broken. Whatever streamed is real work the user saw, so
+      // it goes into the ledger the same way a finished turn does — the message
+      // that interrupted this one opens the next turn and reads this as its
+      // history. Same contract Telegram has: "whatever streamed so far is
+      // already sent + logged; the newer message's run continues the thread."
+      if (wasAborted(e, turnAbort)) {
+        const partial = (active.text || "").trim();
+        if (partial || partialTrace.length) {
+          logWebTurn(ctx.channel, {
+            replyText: partial,
+            model: model || null,
+            trace: partialTrace,
+            project: p,
+            inspector: inspectorTrace,
+            reasoning,
+            timeline,
+          });
+        }
+        clearInterval(keepalive);
+        const ev = abortedTurnEvent({ text: partial, trace: partialTrace });
+        turnFrame("aborted", { result: ev.result });
+        send(ev);
+        res.end();
+        return;
+      }
+      clearInterval(keepalive);
       appendSuperAgentErrorTrace(req, e, {
         prompt,
         channel: ctx.channel,
@@ -210,20 +509,23 @@ export function register(api, { projects, registries, plugins, project, config }
         model,
         stream: true,
       });
+      turnFrame("error", { error: e.message });
       send({
         type: "error",
         trace_id: req.apxTraceId,
         error: `${e.message} (trace: ${req.apxTraceId})`,
       });
       res.end();
+    } finally {
+      endActiveTurn(active.id);
     }
-  });
+  }));
 
   // Project-agnostic one-shot summarize endpoint. Used by `apx session resume
   // <id>` when the session lives outside any registered APX project (e.g. a
   // raw Claude/Codex session). Returns { text } so callers can format the
   // summary however they want.
-  api.post("/super-agent/summarize", async (req, res) => {
+  api.post("/super-agent/summarize", asyncRoute(async (req, res) => {
     const { prompt, context_note: contextNote = "", model, max_tokens } = req.body || {};
     if (!prompt) return res.status(400).json({ error: "prompt required" });
     try {
@@ -252,9 +554,9 @@ export function register(api, { projects, registries, plugins, project, config }
     } catch (e) {
       res.status(500).json({ error: e.message });
     }
-  });
+  }));
 
-  api.post("/projects/:pid/super-agent/chat", async (req, res) => {
+  api.post("/projects/:pid/super-agent/chat", asyncRoute(async (req, res) => {
     const p = project(req, res);
     if (!p) return;
     const { prompt, previousMessages, model, maxIters, maxTokens, completionContract } =
@@ -262,15 +564,30 @@ export function register(api, { projects, registries, plugins, project, config }
     if (!prompt) return res.status(400).json({ error: "prompt required" });
     const ctx = resolveSuperAgentContext(req, p);
     const inspectorOn = isInspectorEnabled(config);
+    let inspectorTrace = null;
+    const reasoning = [];
     if (inspectorOn) {
       try {
         const out = await inspectPromptForSkills({ prompt, projectPath: p.path, globalConfig: config });
+        inspectorTrace = out.trace;
         if (out.contextNote) {
           ctx.contextNote = [ctx.contextNote, out.contextNote].filter(Boolean).join("\n\n");
         }
         logInspectorDecision(out.trace, { trace_id: req.apxTraceId, channel: ctx.channel });
       } catch { /* inspector failure must not block the turn */ }
     }
+    // The message is on the record before the turn starts. This is the endpoint
+    // the phone bridge posts to, and its turns are the long ones.
+    logInboundTurn(ctx.channel, { prompt, project: p });
+    // Nothing is streamed to this caller, but the turn can still produce prose
+    // before its closing comes back empty — which is what tells the floor
+    // whether the turn worked or did nothing at all.
+    let lastSaid = "";
+    const logged = wrapOnEventForLog(null, {
+      trace_id: req.apxTraceId,
+      channel: ctx.channel,
+      reasoning,
+    });
     try {
       const saResult = await runSuperAgent({
         globalConfig: config,
@@ -286,22 +603,36 @@ export function register(api, { projects, registries, plugins, project, config }
         ...(Number.isFinite(Number(maxIters)) ? { maxIters: Number(maxIters) } : {}),
         ...(Number.isFinite(Number(maxTokens)) ? { maxTokens: Number(maxTokens) } : {}),
         ...(completionContract ? { completionContract: true } : {}),
-        onEvent: wrapOnEventForLog(null, {
-          trace_id: req.apxTraceId,
-          channel: ctx.channel,
-        }),
+        onEvent: (ev) => {
+          if (ev?.type === "assistant_text" && String(ev.text || "").trim()) {
+            lastSaid = String(ev.text).trim();
+          }
+          return logged(ev);
+        },
         skipSkillsHint: inspectorOn,
       });
       projects.rebuild(p.id);
+      // Same floor as the streamed route: an empty answer is never what this
+      // endpoint returns. `apx exec` and the phone bridge both read `text`.
+      const closing = await floorReplyText({
+        globalConfig: config,
+        text: saResult.text,
+        streamedText: lastSaid,
+        trace: saResult.trace,
+      });
+      if (closing.floored) logFlooredTurn(closing, { trace_id: req.apxTraceId, channel: ctx.channel });
       logWebTurn(ctx.channel, {
-        prompt,
-        replyText: saResult.text,
+        replyText: closing.text,
         name: saResult.name,
         model: saResult.model,
         usage: saResult.usage,
+        trace: saResult.trace,
+        project: p,
+        inspector: inspectorTrace,
+        reasoning,
       });
       res.json({
-        text: saResult.text,
+        text: closing.text,
         usage: saResult.usage,
         name: saResult.name,
         model: saResult.model,
@@ -317,5 +648,5 @@ export function register(api, { projects, registries, plugins, project, config }
       });
       res.status(500).json({ error: e.message, trace_id: req.apxTraceId });
     }
-  });
+  }));
 }