aui-agent-builder 0.3.109 → 0.3.111

package/dist/api-client/index.js

@@ -352,21 +352,82 @@ export class AUIClient {
             if (filters?.network_category_id)
                 qs.set("network_category_id", filters.network_category_id);
             const url = `${getAgentManagementBaseUrl()}/v1/agents?${qs}`;
-            const resp = await this.agentManagementFetch(url, {
+            // `list_agents` is the fallback resolver used by `aui pull` /
+            // `aui import-agent` when `.auirc` has no `agent_management_id`
+            // (legacy projects pre-PR #54). Full preflight telemetry —
+            // curl repro + truncated response — so Logfire shows which
+            // sibling agents the resolver saw and which one it picked.
+            // Mirrors the contract used by `get_agent` and `get_version`.
+            const { resp, responseText } = await this.preflightFetch({
+                name: "list_agents",
+                label: "list agents",
+                url,
                 method: "GET",
-                headers: this.agentManagementHeaders(),
-            }, "list agents");
+                extraAttrs: {
+                    organization_id: orgId,
+                    page,
+                    size,
+                    ...(filters?.network_id
+                        ? { filter_network_id: filters.network_id }
+                        : {}),
+                    ...(filters?.network_category_id
+                        ? { filter_network_category_id: filters.network_category_id }
+                        : {}),
+                    ...(filters?.scope_type ? { filter_scope_type: filters.scope_type } : {}),
+                    ...(filters?.kind ? { filter_kind: filters.kind } : {}),
+                },
+                extractAttrs: (parsed) => {
+                    const out = {};
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        const obj = parsed;
+                        if (Array.isArray(obj.items))
+                            out.items_count = obj.items.length;
+                        if (typeof obj.total === "number")
+                            out.total = obj.total;
+                        if (typeof obj.pages === "number")
+                            out.pages = obj.pages;
+                        // Capture the bundle_mode breakdown for the page — useful
+                        // when the resolver picks the "wrong" sibling on a
+                        // bundle/records mixed account.
+                        if (Array.isArray(obj.items)) {
+                            let bundleTrue = 0;
+                            let bundleFalse = 0;
+                            let bundleUnset = 0;
+                            for (const it of obj.items) {
+                                const bm = it && typeof it === "object"
+                                    ? it.bundle_mode
+                                    : undefined;
+                                if (bm === true)
+                                    bundleTrue++;
+                                else if (bm === false)
+                                    bundleFalse++;
+                                else
+                                    bundleUnset++;
+                            }
+                            out.items_bundle_mode_true = bundleTrue;
+                            out.items_bundle_mode_false = bundleFalse;
+                            out.items_bundle_mode_unset = bundleUnset;
+                        }
+                    }
+                    return out;
+                },
+            });
             if (!resp.ok) {
                 let errorBody;
                 try {
-                    errorBody = await resp.json();
+                    errorBody = JSON.parse(responseText);
                 }
                 catch {
-                    errorBody = await resp.text();
+                    errorBody = responseText || null;
                 }
                 throw new AUIAPIError(resp.status, `agents: ${resp.statusText}`, errorBody);
             }
-            return (await resp.json());
+            try {
+                return JSON.parse(responseText);
+            }
+            catch {
+                throw new AUIAPIError(resp.status, `agents: invalid JSON response`, responseText);
+            }
         },
         listVersions: async (agentId, page = 1, size = 50, filters) => {
             const qs = new URLSearchParams({
@@ -424,59 +485,44 @@ export class AUIClient {
             // "import keeps failing on this agent", the FIRST question is
             // "what did the get-agent response say (especially bundle_mode)?".
             //
-            // To answer that straight from Logfire — without re-running the
-            // CLI with `AUI_DEBUG=1` — we attach an event on the active span
-            // (`aui.import` / `aui.pull` / `aui.push`) carrying the full
-            // curl repro (auth redacted), HTTP method/url/status, duration,
-            // and the response body. Using `addEvent` (vs `setAttribute`)
-            // preserves multiple per-command calls: push's
-            // `lookupAgentManagementInfoForPush` + `resolveVersionDraft` can
-            // call `getAgent` more than once, and we want each call visible
-            // as its own log entry under the parent span.
+            // Telemetry is wired through `preflightFetch` (shared with
+            // `getVersion` and `listAgents`), which attaches a span event
+            // with curl repro, status, duration, and response body. Using
+            // `addEvent` (vs `setAttribute`) preserves multiple per-command
+            // calls: push's `lookupAgentManagementInfoForPush` +
+            // `resolveVersionDraft` can call `getAgent` more than once, and
+            // we want each call visible as its own log entry under the
+            // parent span.
             const url = `${getAgentManagementBaseUrl()}/v1/agents/${agentId}`;
-            const method = "GET";
-            const headers = this.agentManagementHeaders();
-            const startedAt = Date.now();
-            let resp;
-            try {
-                resp = await this.agentManagementFetch(url, { method, headers }, "get agent");
-            }
-            catch (err) {
-                // Network-level failure (DNS, ECONNREFUSED, timeout, abort, ...).
-                // Attach the request-side telemetry before re-throwing so the
-                // span tells the full story even when there's no HTTP response.
-                const networkErr = err instanceof Error ? err : new Error(String(err));
-                this.attachGetAgentTelemetry({
-                    method,
-                    url,
-                    headers,
-                    agentId,
-                    responseText: networkErr.message,
-                    status: 0,
-                    success: false,
-                    durationMs: Date.now() - startedAt,
-                });
-                throw networkErr;
-            }
-            // Read the body ONCE — Response bodies are single-shot and we
-            // need the same string for telemetry, error envelopes, and the
-            // success JSON parse below. Mirrors the validate-call path.
-            let responseText;
-            try {
-                responseText = await resp.text();
-            }
-            catch {
-                responseText = "";
-            }
-            this.attachGetAgentTelemetry({
-                method,
+            const { resp, responseText } = await this.preflightFetch({
+                name: "get_agent",
+                label: "get agent",
                 url,
-                headers,
-                agentId,
-                responseText,
-                status: resp.status,
-                success: resp.ok,
-                durationMs: Date.now() - startedAt,
+                method: "GET",
+                extraAttrs: { agent_id: agentId },
+                extractAttrs: (parsed, spanAttrs) => {
+                    const out = {};
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        const obj = parsed;
+                        if (typeof obj.bundle_mode === "boolean") {
+                            out.bundle_mode = obj.bundle_mode;
+                            // Also pin the most-recent observed mode at the span level
+                            // so it's filterable without expanding the event list.
+                            // Multiple calls per command overwrite — the last call
+                            // wins, which is the one whose decision actually drove
+                            // the dispatch.
+                            spanAttrs["agent.bundle_mode"] = obj.bundle_mode;
+                        }
+                        if (typeof obj.name === "string")
+                            out.agent_name = obj.name;
+                        if (typeof obj.active_version_id === "string") {
+                            out.active_version_id = obj.active_version_id;
+                        }
+                        if (typeof obj.kind === "string")
+                            out.agent_kind = obj.kind;
+                    }
+                    return out;
+                },
             });
             if (!resp.ok) {
                 let errorBody;
@@ -534,22 +580,58 @@ export class AUIClient {
             return (await resp.json());
         },
         getVersion: async (agentId, versionId) => {
+            // `GET /v1/agents/{id}/versions/{id}` is the second preflight read
+            // every push/pull issues — it resolves the draft target (and
+            // returns the version's `status`, `version_number`, etc.). When
+            // a user reports "push failed with 422 not-a-draft" or "pull
+            // returned 404", the diff between WHAT the CLI saw here and WHAT
+            // it then sent on /push or /pull is the smoking gun. Full
+            // preflight telemetry — curl repro + truncated response — keeps
+            // both pieces of evidence in one Logfire row.
             const url = `${getAgentManagementBaseUrl()}/v1/agents/${agentId}/versions/${versionId}`;
-            const resp = await this.agentManagementFetch(url, {
+            const { resp, responseText } = await this.preflightFetch({
+                name: "get_version",
+                label: "get version",
+                url,
                 method: "GET",
-                headers: this.agentManagementHeaders(),
-            }, "get version");
+                extraAttrs: { agent_id: agentId, version_id: versionId },
+                extractAttrs: (parsed) => {
+                    const out = {};
+                    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                        const obj = parsed;
+                        if (typeof obj.status === "string")
+                            out.status = obj.status;
+                        if (typeof obj.version_number === "number") {
+                            out.version_number = obj.version_number;
+                        }
+                        if (typeof obj.version_revision_number === "number") {
+                            out.version_revision_number = obj.version_revision_number;
+                        }
+                        if (typeof obj.label === "string")
+                            out.label = obj.label;
+                        if (typeof obj.is_active === "boolean") {
+                            out.is_active = obj.is_active;
+                        }
+                    }
+                    return out;
+                },
+            });
             if (!resp.ok) {
                 let errorBody;
                 try {
-                    errorBody = await resp.json();
+                    errorBody = JSON.parse(responseText);
                 }
                 catch {
-                    errorBody = await resp.text();
+                    errorBody = responseText || null;
                 }
                 throw new AUIAPIError(resp.status, `get version: ${resp.statusText}`, errorBody);
             }
-            return (await resp.json());
+            try {
+                return JSON.parse(responseText);
+            }
+            catch {
+                throw new AUIAPIError(resp.status, `get version: invalid JSON response`, responseText);
+            }
         },
         updateVersion: async (agentId, versionId, data) => {
             const url = `${getAgentManagementBaseUrl()}/v1/agents/${agentId}/versions/${versionId}`;
@@ -854,28 +936,54 @@ export class AUIClient {
             }
             if (pushTimer)
                 clearTimeout(pushTimer);
+            // Read the body ONCE — used for telemetry, the error envelope,
+            // and the success parse. (Web fetch bodies are single-shot.)
+            const responseText = await resp.text();
+            // Summary body for both captureRequest and the span curl. We do
+            // NOT inline the full bundle (it can be megabytes) — the
+            // reproducible signal for a push is the endpoint + the RESPONSE
+            // (new_version_tag on success, or the 422 BundleValidationResult
+            // on failure), both of which we capture in full (truncated 32KB).
+            const pushSummaryBody = {
+                caller: reqBody.caller,
+                commit_message: reqBody.commit_message,
+                pushed_by: reqBody.pushed_by,
+                bundle_size_bytes: serialized.length,
+            };
             captureRequest({
                 timestamp: new Date().toISOString(),
                 method: "POST",
                 url,
                 headers,
-                body: {
-                    caller: reqBody.caller,
-                    commit_message: reqBody.commit_message,
-                    pushed_by: reqBody.pushed_by,
-                    bundle_size_bytes: serialized.length,
-                },
+                body: pushSummaryBody,
                 status: resp.status,
+                responseBody: responseText,
                 label: "push version blobs",
                 success: resp.ok,
             });
+            // Attach the replayable curl + response to the active span
+            // (`aui.push.task.bundle`) for BOTH success and failure, so the
+            // bundle-mode push endpoint is fully visible in Logfire — the
+            // counterpart to the records-mode per-entity write curls.
+            this.attachHttpCurlTelemetry({
+                name: "push_bundle",
+                label: "push version blobs",
+                method: "POST",
+                url,
+                headers,
+                requestBody: pushSummaryBody,
+                responseText,
+                status: resp.status,
+                success: resp.ok,
+                durationMs: Date.now() - pushStart,
+            });
             if (!resp.ok) {
                 let errorBody;
                 try {
-                    errorBody = await resp.json();
+                    errorBody = JSON.parse(responseText);
                 }
                 catch {
-                    errorBody = await resp.text();
+                    errorBody = responseText;
                 }
                 if (process.env.AUI_DEBUG) {
                     console.log(`[debug] push version blobs failed: ${resp.status} ${JSON.stringify(errorBody)}`);
@@ -908,7 +1016,7 @@ export class AUIClient {
             }
             let responseData;
             try {
-                responseData = (await resp.json());
+                responseData = (responseText ? JSON.parse(responseText) : undefined);
             }
             catch {
                 responseData = undefined;
@@ -942,25 +1050,42 @@ export class AUIClient {
             if (process.env.AUI_DEBUG) {
                 console.log(`[debug] GET ${url}`);
             }
-            const resp = await this.agentManagementFetch(url, {
+            const pullHeaders = {
+                Accept: "application/json",
+                Authorization: `Bearer ${this.authToken}`,
+                "X-Organization-ID": this.organizationId,
+            };
+            const pullStart = Date.now();
+            const resp = await this.agentManagementFetch(url, { method: "GET", headers: pullHeaders }, "pull version blobs");
+            // Read the body ONCE — used for telemetry, the error envelope,
+            // and the success parse.
+            const responseText = await resp.text();
+            // Attach the replayable curl + response to the active span
+            // (`aui.pull` / `aui.import`) for the bundle-mode `/pull` read —
+            // the counterpart to the records-mode `/view` read curls, so the
+            // import endpoint is fully visible in Logfire for both modes.
+            this.attachHttpCurlTelemetry({
+                name: "pull_bundle",
+                label: "pull version blobs",
                 method: "GET",
-                headers: {
-                    Accept: "application/json",
-                    Authorization: `Bearer ${this.authToken}`,
-                    "X-Organization-ID": this.organizationId,
-                },
-            }, "pull version blobs");
+                url,
+                headers: pullHeaders,
+                responseText,
+                status: resp.status,
+                success: resp.ok,
+                durationMs: Date.now() - pullStart,
+            });
             if (!resp.ok) {
                 let errorBody;
                 try {
-                    errorBody = await resp.json();
+                    errorBody = JSON.parse(responseText);
                 }
                 catch {
-                    errorBody = await resp.text();
+                    errorBody = responseText;
                 }
                 throw new AUIAPIError(resp.status, `pull version blobs: ${resp.statusText}`, errorBody);
             }
-            return (await resp.json());
+            return JSON.parse(responseText);
         },
         /**
          * @deprecated Multipart-files upload was removed on 2026-05-20. The
@@ -1172,17 +1297,26 @@ export class AUIClient {
         }
     }
     /**
-     * Attach `GET /v1/agents/{id}` telemetry to the currently-active span
-     * (typically `aui.import` / `aui.pull` / `aui.push`). The CLI calls
-     * this endpoint before every import/pull/push to read `bundle_mode`
-     * and decide which surface to use — so making every call self-
-     * describing in Logfire (curl repro, status, response body, duration)
-     * answers "did the CLI even know the right mode?" without re-running
-     * locally. See the comment block in `getAgent` for the rationale.
+     * Attach preflight HTTP telemetry to the currently-active span
+     * (typically `aui.import` / `aui.pull` / `aui.push`).
+     *
+     * The CLI fires up to three preflight reads BEFORE issuing the
+     * actual push/pull body:
+     *   1. `GET /v1/agents/{id}`               → reads `bundle_mode`
+     *   2. `GET /v1/agents/{id}/versions/{id}` → resolves the draft/version
+     *   3. `GET /v1/agents?network_id=…`       → legacy-project fallback
+     *      when `.auirc` has no `agent_management_id`.
+     *
+     * All three are essential for triaging "push hit the wrong endpoint"
+     * / "pull pulled the wrong version" reports. Each one is emitted as
+     * its own span event with the full curl repro (auth redacted),
+     * status, duration, response body (truncated), and a handful of
+     * extracted highlights pulled by `extractAttrs` (e.g. `bundle_mode`,
+     * `active_version_id`, version `status`, item counts).
      *
      * Best-effort throughout: telemetry must NEVER break the call path.
      */
-    attachGetAgentTelemetry(input) {
+    attachPreflightTelemetry(input) {
         try {
             const span = trace.getActiveSpan();
             if (!span)
@@ -1192,42 +1326,21 @@ export class AUIClient {
                 ? input.responseText.slice(0, MAX) +
                     `... [truncated ${input.responseText.length - MAX} bytes]`
                 : input.responseText;
-            // Best-effort: surface `bundle_mode` as its own event attribute
-            // so dashboards can filter "show me every push where the agent
-            // reported bundle_mode=false" without grepping response bodies.
-            let bundleMode;
-            let agentName;
-            let activeVersionId;
-            try {
-                const parsed = JSON.parse(input.responseText);
-                if (typeof parsed.bundle_mode === "boolean") {
-                    bundleMode = parsed.bundle_mode;
-                }
-                if (typeof parsed.name === "string")
-                    agentName = parsed.name;
-                if (typeof parsed.active_version_id === "string") {
-                    activeVersionId = parsed.active_version_id;
-                }
-            }
-            catch {
-                // Response wasn't JSON (network failure stringified error,
-                // 5xx HTML page, etc.) — fall through with bundleMode unset.
-            }
             const eventAttrs = {
                 "http.method": input.method,
                 "http.url": input.url,
-                "get_agent.agent_id": input.agentId,
-                "get_agent.duration_ms": input.durationMs,
-                "get_agent.success": input.success,
-                "get_agent.response_body": truncatedResponse,
+                [`${input.name}.duration_ms`]: input.durationMs,
+                [`${input.name}.success`]: input.success,
+                [`${input.name}.response_body`]: truncatedResponse,
                 "aui.curl_repro": formatAsCurlSafe({
                     timestamp: new Date().toISOString(),
                     method: input.method,
                     url: input.url,
                     headers: input.headers,
+                    body: input.requestBody,
                     status: input.status,
                     responseBody: input.responseText,
-                    label: "get agent",
+                    label: input.label,
                     success: input.success,
                 }, { maxBodyBytes: MAX }),
             };
@@ -1238,20 +1351,157 @@ export class AUIClient {
             if (input.status > 0) {
                 eventAttrs["http.status_code"] = input.status;
             }
-            if (typeof bundleMode === "boolean") {
-                eventAttrs["get_agent.bundle_mode"] = bundleMode;
-                // Also pin the most-recent observed mode at the span level so
-                // it's filterable without expanding the event list. Multiple
-                // calls per command overwrite — the last call wins, which is
-                // the one whose decision actually drove the dispatch.
-                span.setAttribute("agent.bundle_mode", bundleMode);
+            if (input.extraAttrs) {
+                for (const [k, v] of Object.entries(input.extraAttrs)) {
+                    eventAttrs[`${input.name}.${k}`] = v;
+                }
             }
-            if (agentName)
-                eventAttrs["get_agent.agent_name"] = agentName;
-            if (activeVersionId) {
-                eventAttrs["get_agent.active_version_id"] = activeVersionId;
+            // Parse the response body once for the per-endpoint highlight
+            // extractor. The extractor can also push attributes onto the
+            // parent span (`spanAttrs`) for things that are stable across
+            // every call (e.g. `agent.bundle_mode`).
+            if (input.extractAttrs) {
+                const spanAttrs = {};
+                try {
+                    const parsed = JSON.parse(input.responseText);
+                    const extracted = input.extractAttrs(parsed, spanAttrs) || {};
+                    for (const [k, v] of Object.entries(extracted)) {
+                        eventAttrs[`${input.name}.${k}`] = v;
+                    }
+                }
+                catch {
+                    // Response wasn't JSON (network failure stringified error,
+                    // 5xx HTML page, etc.) — fall through without highlights.
+                }
+                for (const [k, v] of Object.entries(spanAttrs)) {
+                    span.setAttribute(k, v);
+                }
+            }
+            span.addEvent(input.name, eventAttrs);
+        }
+        catch {
+            // Telemetry must never break the call path.
+        }
+    }
+    /**
+     * Run a preflight `agentManagementFetch` and attach full
+     * curl+request+response telemetry to the active span. Use for
+     * `GET` reads that drive the push/pull dispatch (getAgent,
+     * getVersion, listAgents). Returns the response text so callers
+     * still parse the body themselves — keeps the existing single-
+     * read-once invariant from `getAgent` (response bodies are
+     * single-shot).
+     */
+    async preflightFetch(input) {
+        const headers = this.agentManagementHeaders();
+        const startedAt = Date.now();
+        let resp;
+        try {
+            resp = await this.agentManagementFetch(input.url, { method: input.method, headers }, input.label);
+        }
+        catch (err) {
+            const networkErr = err instanceof Error ? err : new Error(String(err));
+            this.attachPreflightTelemetry({
+                name: input.name,
+                label: input.label,
+                method: input.method,
+                url: input.url,
+                headers,
+                responseText: networkErr.message,
+                status: 0,
+                success: false,
+                durationMs: Date.now() - startedAt,
+                extraAttrs: input.extraAttrs,
+                extractAttrs: input.extractAttrs,
+            });
+            throw networkErr;
+        }
+        let responseText;
+        try {
+            responseText = await resp.text();
+        }
+        catch {
+            responseText = "";
+        }
+        this.attachPreflightTelemetry({
+            name: input.name,
+            label: input.label,
+            method: input.method,
+            url: input.url,
+            headers,
+            responseText,
+            status: resp.status,
+            success: resp.ok,
+            durationMs: Date.now() - startedAt,
+            extraAttrs: input.extraAttrs,
+            extractAttrs: input.extractAttrs,
+        });
+        return { resp, responseText };
+    }
+    /**
+     * Attach a redacted curl + request/response telemetry to the active
+     * span for the core import/push endpoints (the `/pull` & `/push`
+     * bundle routes and the records-mode `/view` reads & per-entity
+     * writes). These already land in `aui curl` (via `captureRequest`)
+     * and `.aui/push-logs/`, but were NOT visible in Logfire — so a
+     * failed bundle push or a wrong-version pull showed only a span
+     * with a bare error string. This makes the exact replayable curl +
+     * (truncated) response body part of the trace, for BOTH success and
+     * failure, in both records and bundle mode.
+     *
+     * Emits a `http.<name>` event (preserves history when several calls
+     * share one span, e.g. the ~6 `/view` reads under a single
+     * `aui.import`) AND mirrors the curl + HTTP fields onto the span
+     * itself (so a dedicated per-call task span like
+     * `aui.push.task.bundle` / `aui.push.task.<entity>` shows the curl
+     * directly in its attributes). For multi-call spans the span-level
+     * attrs are last-call-wins; the per-call events retain every curl.
+     *
+     * Best-effort throughout: telemetry must NEVER break the call path.
+     */
+    attachHttpCurlTelemetry(input) {
+        try {
+            const span = trace.getActiveSpan();
+            if (!span)
+                return;
+            const MAX = 32 * 1024;
+            const truncatedResponse = input.responseText.length > MAX
+                ? input.responseText.slice(0, MAX) +
+                    `... [truncated ${input.responseText.length - MAX} bytes]`
+                : input.responseText;
+            const curl = formatAsCurlSafe({
+                timestamp: new Date().toISOString(),
+                method: input.method,
+                url: input.url,
+                headers: input.headers,
+                body: input.requestBody,
+                status: input.status,
+                responseBody: input.responseText,
+                label: input.label,
+                success: input.success,
+            }, { maxBodyBytes: MAX });
+            const eventAttrs = {
+                "http.method": input.method,
+                "http.url": input.url,
+                [`${input.name}.success`]: input.success,
+                [`${input.name}.response_body`]: truncatedResponse,
+                "aui.curl_repro": curl,
+            };
+            if (input.status > 0)
+                eventAttrs["http.status_code"] = input.status;
+            if (typeof input.durationMs === "number") {
+                eventAttrs[`${input.name}.duration_ms`] = input.durationMs;
+            }
+            span.addEvent(`http.${input.name}`, eventAttrs);
+            // Mirror onto the span for direct visibility on dedicated
+            // per-call spans (push bundle / per-entity write task spans).
+            span.setAttribute("aui.curl_repro", curl);
+            span.setAttribute("http.method", input.method);
+            span.setAttribute("http.url", input.url);
+            span.setAttribute("http.response_body", truncatedResponse);
+            if (input.status > 0) {
+                span.setAttribute("http.status_code", input.status);
             }
-            span.addEvent("get_agent", eventAttrs);
         }
         catch {
             // Telemetry must never break the call path.
@@ -1500,20 +1750,40 @@ export class AUIClient {
             console.log(`[debug] GET ${url}`);
         }
         const hdrs = this.agentSettingsReadHeaders();
+        const startedAt = Date.now();
         const resp = await fetch(url, { method: "GET", headers: hdrs });
+        // Read the body ONCE — used for telemetry, the error envelope, and
+        // the success parse. node-fetch bodies are single-shot.
+        const responseText = await resp.text();
         if (resp.status === 401 && !_isRetry) {
             const refreshed = await this.attemptTokenRefresh();
             if (refreshed) {
                 return this.fetchV2(path, params, true);
             }
         }
+        // Attach the replayable curl + response to the active span for the
+        // records-mode `/view` reads `aui import` / `aui pull` issue (the
+        // ~6 per-entity reads run under one `aui.import` / `aui.pull`
+        // span). Success + failure, so the import endpoints are fully
+        // visible in Logfire — not just `aui curl`.
+        this.attachHttpCurlTelemetry({
+            name: "import_view",
+            label: `GET ${path}`,
+            method: "GET",
+            url,
+            headers: hdrs,
+            responseText,
+            status: resp.status,
+            success: resp.ok,
+            durationMs: Date.now() - startedAt,
+        });
         if (!resp.ok) {
             let errorBody;
             try {
-                errorBody = await resp.json();
+                errorBody = JSON.parse(responseText);
             }
             catch {
-                errorBody = await resp.text();
+                errorBody = responseText;
             }
             if (process.env.AUI_DEBUG) {
                 console.log(`[debug] ${path} → ${resp.status}: ${JSON.stringify(errorBody)}`);
@@ -1532,7 +1802,7 @@ export class AUIClient {
             err.statusCode = resp.status;
             throw err;
         }
-        const data = await resp.json();
+        const data = responseText ? JSON.parse(responseText) : {};
         captureRequest({
             timestamp: new Date().toISOString(),
             method: "GET",
@@ -1677,6 +1947,22 @@ export class AUIClient {
             label: label || `${method} ${path}`,
             success: resp.ok,
         });
+        // Attach the replayable curl + response to the active span for
+        // BOTH success and failure (records-mode per-entity writes run
+        // inside their own `aui.push.task.<entity>` span). Previously only
+        // failures got a curl here; the owner asked for curl on every
+        // pushed endpoint so triage never depends on `.aui/push-logs/`.
+        this.attachHttpCurlTelemetry({
+            name: "entity_write",
+            label: label || `${method} ${path}`,
+            method,
+            url,
+            headers,
+            requestBody: body,
+            responseText,
+            status: resp.status,
+            success: resp.ok,
+        });
         if (this.pushLogDir) {
             this.writePushLog(method, url, headers, body, resp.status, responseText, label);
         }
@@ -1690,33 +1976,6 @@ export class AUIClient {
             if (process.env.AUI_DEBUG) {
                 console.log(`[debug] ${method} ${path} → ${resp.status}: ${responseText}`);
             }
-            // Attach replayable context to the active span so triage from
-            // Logfire doesn't require fishing in `.aui/push-logs/*.txt` or
-            // `~/.aui/last-requests.json`. Failure path only — adding curl
-            // to every successful write would multiply telemetry egress and
-            // surface bodies for traffic that doesn't need triage.
-            try {
-                const activeSpan = trace.getActiveSpan();
-                if (activeSpan) {
-                    activeSpan.setAttribute("http.method", method);
-                    activeSpan.setAttribute("http.url", url);
-                    activeSpan.setAttribute("http.status_code", resp.status);
-                    activeSpan.setAttribute("aui.curl_repro", formatAsCurlSafe({
-                        timestamp: new Date().toISOString(),
-                        method,
-                        url,
-                        headers,
-                        body,
-                        status: resp.status,
-                        responseBody: responseText,
-                        label,
-                        success: false,
-                    }, { maxBodyBytes: 32_768 }));
-                }
-            }
-            catch {
-                // Telemetry must never break the call path.
-            }
             const error = new Error(`${label} failed: ${resp.status} ${responseText}`);
             error.statusCode = resp.status;
             throw error;