fix(agent): drop console export and resolve root span status from latest turn

Addresses two external review findings:

- _posthog/console records are no longer exported to PostHog Logs. Console
  lines are free-text agent-server diagnostics that interpolate arbitrary
  data - the user-message handler logs a 100-char prompt preview and the
  extension-notification handler stringifies params into that channel - so
  exporting them verbatim violated the metadata-only allowlist. They remain
  in the S3 session log and the event-ingest stream. Regression tests assert
  console entries (including an interpolated prompt preview) never map to an
  exported record.

- The task_run root span status is now resolved at shutdown from the LATEST
  turn outcome instead of being set sticky-OK on the first clean end_turn.
  A multi-turn run whose final turn is cancelled/refused no longer reports
  OK; a run error still always wins. The root span only exports at end, so
  per-turn status writes were cosmetic anyway.

Stacked on posthog-code/agent-run-otel-telemetry (pure fast-forward).

Generated-By: PostHog Code
Task-Id: 0c511836-2180-455a-9b58-45df2a0661ec

Author: tatoalo

packages/agent/src/otel-telemetry.test.ts

@@ -170,21 +170,6 @@ describe("OtelRunTelemetry", () => {
         body: "error: boom",
         attrs: { error_source: "agent_server" },
       },
-      {
-        name: "console warn",
-        entry: makeEntry("_posthog/console", {
-          level: "warn",
-          message: "careful",
-        }),
-        severityText: "WARN",
-        body: "careful",
-      },
-      {
-        name: "console with unknown level",
-        entry: makeEntry("_posthog/console", { level: "silly", message: "m" }),
-        severityText: "INFO",
-        body: "m",
-      },
       {
         name: "progress",
         entry: makeEntry("_posthog/progress", {
@@ -321,16 +306,29 @@ describe("OtelRunTelemetry", () => {
         "user_message",
         makeEntry("_posthog/user_message", { message: "SECRET" }),
       ],
+      // Console lines are free-text agent-server diagnostics; some interpolate
+      // content (e.g. the prompt preview logged on user_message handling).
+      [
+        "console with interpolated prompt preview",
+        makeEntry("_posthog/console", {
+          level: "debug",
+          message: "Processing user message (detectedPrUrl=none): SECRET...",
+        }),
+      ],
+      [
+        "console error",
+        makeEntry("_posthog/console", { level: "error", message: "SECRET" }),
+      ],
       ["unknown extension method", makeEntry("_posthog/some_new_event", {})],
     ])("drops %s", (_name, entry) => {
       expect(mapNotificationToLogRecord(entry)).toBeNull();
     });
 
     it("caps body length", () => {
       const mapped = mapNotificationToLogRecord(
-        makeEntry("_posthog/console", {
-          level: "info",
-          message: "x".repeat(5000),
+        makeEntry("_posthog/error", {
+          source: "agent_server",
+          error: "x".repeat(5000),
         }),
       );
 
@@ -531,6 +529,27 @@ describe("OtelRunTelemetry", () => {
       expect(surface).not.toContain(".env");
     });
 
+    it("does not leave root OK when a later turn ends non-clean", async () => {
+      driveSuccessfulRun();
+      // Second turn gets cancelled: the latest outcome wins, so the earlier
+      // clean turn must not leave the run marked OK.
+      telemetry.append(
+        RUN_ID,
+        makeEntry("session/prompt", {
+          prompt: [{ type: "text", text: "again" }],
+        }),
+      );
+      telemetry.append(
+        RUN_ID,
+        makeEntry("_posthog/turn_complete", { stopReason: "cancelled" }),
+      );
+
+      await telemetry.shutdown();
+
+      expect(spanByName("task_run").status.code).toBe(SpanStatusCode.UNSET);
+      expect(exportedSpans().filter((s) => s.name === "turn")).toHaveLength(2);
+    });
+
     it("stamps log records with the span they belong to", async () => {
       driveSuccessfulRun();
 

packages/agent/src/otel-telemetry.ts

@@ -67,13 +67,6 @@ export interface MappedLogRecord {
   attributes: Attributes;
 }
 
-const CONSOLE_SEVERITIES: Record<string, [SeverityNumber, string]> = {
-  debug: [SeverityNumber.DEBUG, "DEBUG"],
-  info: [SeverityNumber.INFO, "INFO"],
-  warn: [SeverityNumber.WARN, "WARN"],
-  error: [SeverityNumber.ERROR, "ERROR"],
-};
-
 function record(
   severity: [SeverityNumber, string],
   body: string,
@@ -88,9 +81,9 @@ function record(
   };
 }
 
-const INFO = CONSOLE_SEVERITIES.info;
-const WARN = CONSOLE_SEVERITIES.warn;
-const ERROR = CONSOLE_SEVERITIES.error;
+const INFO: [SeverityNumber, string] = [SeverityNumber.INFO, "INFO"];
+const WARN: [SeverityNumber, string] = [SeverityNumber.WARN, "WARN"];
+const ERROR: [SeverityNumber, string] = [SeverityNumber.ERROR, "ERROR"];
 
 function mapSessionUpdate(
   method: string,
@@ -206,15 +199,11 @@ export function mapNotificationToLogRecord(
         typeof params.error === "string" ? params.error : "unknown error";
       return record(ERROR, `error: ${message}`, method, attrs);
     }
-    case POSTHOG_NOTIFICATIONS.CONSOLE: {
-      const severity =
-        (typeof params.level === "string" &&
-          CONSOLE_SEVERITIES[params.level]) ||
-        INFO;
-      const message =
-        typeof params.message === "string" ? params.message : "console output";
-      return record(severity, message, method, {});
-    }
+    // POSTHOG_NOTIFICATIONS.CONSOLE is deliberately NOT exported: those are
+    // free-text agent-server diagnostics that interpolate arbitrary data
+    // (prompt previews, stringified extension params), so shipping them would
+    // leak content the allowlist exists to keep in the sandbox. They remain
+    // in the S3 session log and the event-ingest stream.
     case POSTHOG_NOTIFICATIONS.PROGRESS: {
       const attrs: Attributes = {};
       strAttr(attrs, "progress_group", params.group);

packages/agent/src/otel-trace-builder.ts

@@ -41,9 +41,12 @@ export interface RunTraceBuilderConfig {
  * the corresponding log record should be emitted under, so logs and spans
  * cross-link in the UI via trace_id/span_id.
  *
- * Root span status: OK once a turn ends cleanly (`end_turn`) or on
- * task_complete, ERROR on a run error (which always wins), unset when the run
- * ends without either (cancelled / timed out).
+ * Root span status is resolved at shutdown from the LATEST turn outcome (the
+ * root span only exports when it ends, so earlier turns must not leave a
+ * sticky OK): OK when the last turn ended cleanly (`end_turn`, or an explicit
+ * task_complete), ERROR on a run error (which always wins) or a last turn
+ * that stopped with `error`, unset otherwise (cancelled / refused / timed out
+ * / no completed turns).
  *
  * Spans carry the same allowlist stance as the log export: lifecycle, status,
  * usage, and identifiers only — never prompts, tool arguments, or output.
@@ -54,6 +57,8 @@ export class RunTraceBuilder {
   private rootSpan: Span;
   private rootContext: Context;
   private rootErrored = false;
+  /** stopReason of the most recent completed turn; drives root status at shutdown */
+  private lastStopReason?: string;
   private turnSpan?: Span;
   private turnContext?: Context;
   private turnIndex = 0;
@@ -109,9 +114,9 @@ export class RunTraceBuilder {
         return this.currentContext();
       }
       case POSTHOG_NOTIFICATIONS.TASK_COMPLETE:
-        if (!this.rootErrored) {
-          this.rootSpan.setStatus({ code: SpanStatusCode.OK });
-        }
+        // Explicit success signal (forward-compat; production decides the
+        // terminal status outside the sandbox) — treated as a clean outcome.
+        this.lastStopReason = "end_turn";
         return this.rootContext;
       case POSTHOG_NOTIFICATIONS.ERROR:
         return this.handleError(params, time);
@@ -126,13 +131,25 @@ export class RunTraceBuilder {
     await this.provider.forceFlush();
   }
 
-  /** Ends any open spans (status unset), then flushes and stops the provider. */
+  /**
+   * Ends any open spans (status unset), resolves the root status from the
+   * latest turn outcome, then flushes and stops the provider.
+   */
   async shutdown(): Promise<void> {
     if (this.ended) return;
     this.ended = true;
     const now = new Date();
     this.closeOpenTools(now);
     this.closeTurn(undefined, now);
+    if (!this.rootErrored) {
+      if (this.lastStopReason === "end_turn") {
+        this.rootSpan.setStatus({ code: SpanStatusCode.OK });
+      } else if (this.lastStopReason === "error") {
+        this.rootSpan.setStatus({ code: SpanStatusCode.ERROR });
+      }
+      // Any other latest outcome (cancelled, refusal, max_tokens, none)
+      // leaves the status unset: neither success nor failure.
+    }
     this.rootSpan.end(now);
     await this.provider.shutdown();
   }
@@ -167,12 +184,11 @@ export class RunTraceBuilder {
     this.closeOpenTools(time);
     this.closeTurn({ stopReason, errored: stopReason === "error" }, time);
     // The sandbox never emits task_complete for successful runs (the terminal
-    // "completed" status is decided by the workflow outside), so a cleanly
-    // finished turn is the success signal for the run. A later error still
-    // wins via rootErrored/handleError.
-    if (stopReason === "end_turn" && !this.rootErrored) {
-      this.rootSpan.setStatus({ code: SpanStatusCode.OK });
-    }
+    // "completed" status is decided by the workflow outside), so the latest
+    // turn outcome is the run's success signal — recorded here, resolved into
+    // the root span status at shutdown so an early clean turn can't leave a
+    // stale OK on a run whose last turn was cancelled.
+    this.lastStopReason = stopReason;
     return context;
   }