@oxygen-agent/cli 1.1010.650 → 1.1010.905

package/dist/http-client.js

@@ -1,5 +1,6 @@
 import { OXYGEN_VERSION, OxygenError, isCliResult, isVersionGreater, parseSemver, readEnvelopeCompatibility, vercelProtectionBypassHeaders, withRetryAfterDetails, } from "@oxygen/shared";
 import { randomUUID } from "node:crypto";
+import { recordMutatingRequestAnswered, recoverFromCliFloorRejection } from "./auto-update.js";
 import { defaultApiUrl, loadCredentialsWithEndpoint } from "./credentials.js";
 import { assertResolvedApiUrl, cliEndpointDetails, describeCliEndpoint, isProdApiUrl, resolveCliUpdateGuidance, } from "./runtime.js";
 const DEFAULT_REQUEST_TIMEOUT_MS = 120_000;
@@ -31,7 +32,14 @@ path, options = {}) {
         ...init, signal: init?.signal ? AbortSignal.any([options.signal, init.signal]) : options.signal,
     }) : baseFetch;
     if (path !== "/api/health" && shouldCheckCliCompatibility(options)) {
-        await ensureFreshCliForApiUrl(apiUrl, { fetch: fetchImpl, endpoint });
+        try {
+            await ensureFreshCliForApiUrl(apiUrl, { fetch: fetchImpl, endpoint });
+        }
+        catch (error) {
+            // The preflight dialed only /api/health: nothing has run yet, so an
+            // automatic update may re-run this command in the new binary.
+            throw error instanceof OxygenError ? await recoverFromCliFloorRejection(error, endpoint) : error;
+        }
     }
     options.signal?.throwIfAborted();
     const traceId = options.traceId ?? randomUUID();
@@ -117,17 +125,33 @@ path, options = {}) {
     }
     const envelope = await readEnvelope(response);
     const compatibility = readEnvelopeCompatibility(envelope);
-    assertCliMeetsMinimumApiVersion(compatibility, options, endpoint);
+    const failed = !response.ok || !envelope.ok;
+    try {
+        assertCliMeetsMinimumApiVersion(compatibility, options, endpoint);
+    }
+    catch (error) {
+        // Only a refused request is safe to re-run: a successful one already did its work.
+        throw failed && error instanceof OxygenError ? await recoverFromCliFloorRejection(error, endpoint) : error;
+    }
     warnIfCliIsOlderThanApi(compatibility.version, endpoint);
-    if (!response.ok || !envelope.ok) {
+    if (failed) {
         const failure = envelope;
         const responseTraceId = response.headers.get("x-oxygen-trace-id") ?? traceId;
         const details = withRetryAfterDetails(failure.error.details, response);
-        throw new OxygenError(failure.error.code, describeFailureAgainstEndpoint(failure.error.code, failure.error.message, endpoint), {
+        const error = new OxygenError(failure.error.code, describeFailureAgainstEndpoint(failure.error.code, failure.error.message, endpoint), {
             details: withTraceDetails(details, responseTraceId, compatibility, endpoint),
             exitCode: 1,
         });
+        // The floor gate refuses before the route does any work (assertCliClientVersionFloor).
+        if (error.code === "cli_update_required")
+            throw await recoverFromCliFloorRejection(error, endpoint);
+        // Any other answer to a write may have written something; never re-run the command after it.
+        if (method !== "GET")
+            recordMutatingRequestAnswered();
+        throw error;
     }
+    if (method !== "GET")
+        recordMutatingRequestAnswered();
     return envelope.data;
 }
 async function readBoundedBinaryResponse(response, maxBytes) {

package/dist/inbox-needs-reply-notice.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A needs-reply inbox list's composition as one terminal line (ADR 0027,
+ * dev-only triage). `inbox list --needs-reply` keeps every thread AI triage has
+ * no verdict on. In the blind acceptance (2026-09-25) the rows' `triage: null`
+ * read as "analysed, no signal", so the agent called the filter leaky and
+ * re-triaged about 140 threads by hand. This line says how many rows carry a
+ * verdict, how many do not, and how to get one.
+ *
+ * Returns null unless the envelope carries `needs_reply_counts`, which the API
+ * sends only on a needs-reply list, so every other command prints nothing.
+ */
+export declare function formatInboxNeedsReplyNotice(data: unknown): string | null;

package/dist/inbox-needs-reply-notice.js

@@ -0,0 +1,51 @@
+import { isRecord } from "./util.js";
+/**
+ * A needs-reply inbox list's composition as one terminal line (ADR 0027,
+ * dev-only triage). `inbox list --needs-reply` keeps every thread AI triage has
+ * no verdict on. In the blind acceptance (2026-09-25) the rows' `triage: null`
+ * read as "analysed, no signal", so the agent called the filter leaky and
+ * re-triaged about 140 threads by hand. This line says how many rows carry a
+ * verdict, how many do not, and how to get one.
+ *
+ * Returns null unless the envelope carries `needs_reply_counts`, which the API
+ * sends only on a needs-reply list, so every other command prints nothing.
+ */
+export function formatInboxNeedsReplyNotice(data) {
+    if (!isRecord(data) || !isRecord(data.needs_reply_counts))
+        return null;
+    const counts = data.needs_reply_counts;
+    const count = (value) => (typeof value === "number" && Number.isFinite(value) ? value : 0);
+    const total = count(counts.total);
+    const judged = count(counts.needs_reply_analysed);
+    const notAnalysed = count(counts.not_analysed_included);
+    const undecided = count(counts.undecided_included);
+    // "kept", not "judged": triages written before needs_reply_decided existed
+    // count as analysed even when the model abstained (conversation-triage.ts).
+    const line = `Needs reply: ${total} threads. Triage kept ${judged} as needing a reply`
+        + `; ${notAnalysed} not analysed yet and ${undecided} undecided stay in because nothing shows they need no reply.`;
+    if (notAnalysed + undecided === 0)
+        return line;
+    const page = pageStatusCounts(data.conversations);
+    const onPage = page ? ` This page: ${page.not_analysed} rows triage_status not_analysed, ${page.undecided} undecided.` : "";
+    // Undecided threads were analysed and the model abstained: a second paid run
+    // on the same message is unlikely to decide, so only not_analysed get the command.
+    const abstained = undecided > 0 ? " Undecided threads were analysed and the model abstained; re-analysing is unlikely to change that." : "";
+    const analyse = notAnalysed > 0
+        ? " Analyse a not_analysed thread now: oxygen inbox analyze <id> --force (add --channel linkedin or whatsapp for a DM; a small paid AI call, managed credits)."
+        : "";
+    return `${line}${onPage}${abstained}${analyse}`;
+}
+function pageStatusCounts(rows) {
+    if (!Array.isArray(rows))
+        return null;
+    const tally = { not_analysed: 0, undecided: 0 };
+    for (const row of rows) {
+        if (!isRecord(row))
+            continue;
+        if (row.triage_status === "not_analysed")
+            tally.not_analysed += 1;
+        else if (row.triage_status === "undecided")
+            tally.undecided += 1;
+    }
+    return tally;
+}