@moda-ai/cli 1.16.0 → 1.17.0

package/dist/api-client.d.ts

@@ -4,6 +4,16 @@ export declare class ApiError extends Error {
     readonly responseBody: string;
     constructor(message: string, statusCode: number, responseBody: string);
 }
+/**
+ * Transport-level failure: the socket died before any HTTP response existed
+ * (`fetch failed`, ECONNRESET, …). Distinct from `ApiError` (an HTTP status)
+ * and from the per-attempt timeout so callers can retry ONLY genuine network
+ * faults — e.g. undici handing out a pooled connection poisoned by a
+ * just-dropped SSE stream on the same origin.
+ */
+export declare class NetworkError extends Error {
+    constructor(message: string);
+}
 export declare function callDataAPI(endpoint: string): Promise<unknown>;
 /**
  * Per-call transport overrides. Used by expensive, long-running, non-idempotent
@@ -15,6 +25,20 @@ export interface ModaRequestOptions {
     timeoutMs?: number;
     /** Max retries (default MAX_RETRIES). Set 0 to disable retries entirely. */
     retries?: number;
+    /**
+     * Retry exactly once more on a NETWORK-level failure, even with `retries: 0`.
+     * After a streamed SSE connection dies, undici's per-origin pool can hand
+     * the very next fetch the same dead socket — the buffered fallback then
+     * fails instantly ("fetch failed") against a healthy backend. The retry
+     * waits ~1s and sends `Connection: close` so it cannot reuse a pooled
+     * connection. HTTP errors (`ApiError`) and the per-attempt timeout NEVER
+     * consume this retry.
+     */
+    retryOnceOnNetworkError?: boolean;
+    /** Delay before the network retry (default 1s; test seam). */
+    networkRetryDelayMs?: number;
+    /** Invoked when the network retry is consumed (callers may log a note). */
+    onNetworkRetry?: () => void;
 }
 export declare function callControlAPI(endpoint: string, options?: RequestInit, profileOptions?: ProfileIOOptions, requestOptions?: ModaRequestOptions): Promise<unknown>;
 export declare function getApiRequestCount(): number;

package/dist/api-client.js

@@ -3,6 +3,7 @@ import { resolveApiKey, resolveModaBaseUrl } from './config.js';
 const REQUEST_TIMEOUT_MS = 30_000;
 const MAX_RETRIES = 3;
 const INITIAL_BACKOFF_MS = 500;
+const NETWORK_RETRY_DELAY_MS = 1_000;
 let apiRequestCount = 0;
 export class ApiError extends Error {
     statusCode;
@@ -14,6 +15,19 @@ export class ApiError extends Error {
         this.name = 'ApiError';
     }
 }
+/**
+ * Transport-level failure: the socket died before any HTTP response existed
+ * (`fetch failed`, ECONNRESET, …). Distinct from `ApiError` (an HTTP status)
+ * and from the per-attempt timeout so callers can retry ONLY genuine network
+ * faults — e.g. undici handing out a pooled connection poisoned by a
+ * just-dropped SSE stream on the same origin.
+ */
+export class NetworkError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'NetworkError';
+    }
+}
 function isRetryable(status) {
     return status === 429 || status >= 500;
 }
@@ -29,10 +43,23 @@ export async function callControlAPI(endpoint, options = {}, profileOptions = {}
 async function callModaAPI(url, options, profileOptions = {}, requestOptions = {}) {
     const timeoutMs = requestOptions.timeoutMs ?? REQUEST_TIMEOUT_MS;
     const maxRetries = requestOptions.retries ?? MAX_RETRIES;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    const initialNetworkRetryBudget = requestOptions.retryOnceOnNetworkError
+        ? 1
+        : 0;
+    let networkRetryBudget = initialNetworkRetryBudget;
+    // Set once the network-retry budget is consumed: the retry attempt (and any
+    // later ones) must not reuse a possibly-poisoned pooled connection.
+    let connectionClose = false;
+    // Structural termination bound: (maxRetries + 1) normal attempts plus at most
+    // one extra network-retry attempt. Every path inside returns, throws, or
+    // `continue`s, so the trailing throw is unreachable — but the bound makes the
+    // contract hold by construction rather than by manual path analysis.
+    const maxAttempts = maxRetries + initialNetworkRetryBudget + 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
         if (attempt > 0) {
-            const backoff = INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
+            const backoff = connectionClose
+                ? requestOptions.networkRetryDelayMs ?? NETWORK_RETRY_DELAY_MS
+                : INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
             await new Promise((resolve) => setTimeout(resolve, backoff));
         }
         const controller = new AbortController();
@@ -44,6 +71,7 @@ async function callModaAPI(url, options, profileOptions = {}, requestOptions = {
                     'x-api-key': resolveApiKey(profileOptions) ?? '',
                     'Content-Type': 'application/json',
                     ...(options.headers ?? {}),
+                    ...(connectionClose ? { Connection: 'close' } : {}),
                 },
                 signal: controller.signal,
             });
@@ -51,7 +79,6 @@ async function callModaAPI(url, options, profileOptions = {}, requestOptions = {
                 const errorText = await response.text();
                 const error = new ApiError(`API error (${response.status}): ${errorText}`, response.status, errorText);
                 if (isRetryable(response.status) && attempt < maxRetries) {
-                    lastError = error;
                     continue;
                 }
                 throw error;
@@ -62,11 +89,16 @@ async function callModaAPI(url, options, profileOptions = {}, requestOptions = {
             if (error instanceof ApiError)
                 throw error;
             const isAbort = error instanceof DOMException && error.name === 'AbortError';
-            const wrapped = new Error(isAbort
-                ? `Request timed out after ${timeoutMs}ms: ${url}`
-                : `Network error: ${error instanceof Error ? error.message : String(error)}`);
+            const wrapped = isAbort
+                ? new Error(`Request timed out after ${timeoutMs}ms: ${url}`)
+                : new NetworkError(`Network error: ${error instanceof Error ? error.message : String(error)}`);
             if (attempt < maxRetries) {
-                lastError = wrapped;
+                continue;
+            }
+            if (!isAbort && networkRetryBudget > 0) {
+                networkRetryBudget -= 1;
+                connectionClose = true;
+                requestOptions.onNetworkRetry?.();
                 continue;
             }
             throw wrapped;
@@ -75,7 +107,9 @@ async function callModaAPI(url, options, profileOptions = {}, requestOptions = {
             clearTimeout(timeout);
         }
     }
-    throw lastError ?? new Error('Request failed after retries');
+    // Unreachable: the loop above always returns or throws within maxAttempts.
+    // Present so the bound is enforced by construction, not just documented.
+    throw new NetworkError(`Request retries exhausted: ${url}`);
 }
 export function getApiRequestCount() {
     return apiRequestCount;

package/dist/ask-stream.d.ts

@@ -25,8 +25,29 @@ export interface AskStreamOutcome {
 }
 /** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
 export declare class AskStreamError extends Error {
+    /** Wall-clock ms the stream ran before failing (annotated by `streamAsk`). */
+    elapsedMs?: number;
+    /** tool_start/tool_end events seen before failing (annotated by `streamAsk`). */
+    toolEvents?: number;
     constructor(message: string);
 }
+/**
+ * Thresholds for "substantial progress": a stream that ran at least this long,
+ * or produced more tool events than this, did real work before dropping —
+ * the buffered fallback then re-runs the WHOLE question, roughly doubling
+ * total latency, so the user deserves a notice instead of silence. The elapsed
+ * check is inclusive (`>=`) so a drop landing exactly on the boundary — where
+ * the doubled wait is felt most acutely — still gets the notice.
+ */
+export declare const SUBSTANTIAL_STREAM_PROGRESS_MS = 60000;
+export declare const SUBSTANTIAL_STREAM_TOOL_EVENTS = 5;
+/**
+ * One-line stderr notice for a stream that died after substantial progress.
+ * Returns null for early failures (they keep today's silent fallback) and for
+ * non-stream errors. The caller still falls back either way — the user must
+ * still get an answer, just an informed wait instead of an apparent hang.
+ */
+export declare function streamFallbackNotice(error: unknown): string | null;
 /**
  * Incremental SSE frame parser. Feed decoded text chunks (arbitrarily split —
  * even mid `data:` line or mid multi-byte frame); complete `data:` payloads
@@ -40,6 +61,33 @@ export declare class SseParser {
     /** Drain a final frame that was not terminated by a blank line. */
     flush(): string[];
 }
+/** Quiet period before the first liveness line is printed. */
+export declare const IDLE_TICKER_THRESHOLD_MS = 10000;
+/** Minimum spacing between liveness lines. */
+export declare const IDLE_TICKER_MIN_UPDATE_MS = 15000;
+/**
+ * Client-side liveness for quiet stream periods: long tool-less LLM turns
+ * (coverage gate, synthesis) emit no events for 30–90s, which reads as a
+ * hang. Once no event has arrived for IDLE_TICKER_THRESHOLD_MS this prints an
+ * unobtrusive "… still working (Ns)" line (at most every
+ * IDLE_TICKER_MIN_UPDATE_MS) through the same progress channel as tool cards —
+ * stderr only, never interleaved into the final answer.
+ */
+export declare class IdleTicker {
+    private readonly write;
+    private readonly now;
+    private startedAt;
+    private lastEventAt;
+    private lastPrintAt;
+    private timer;
+    constructor(write: (line: string) => void, now?: () => number);
+    start(): void;
+    /** Reset the idle clock — call on every real stream event. */
+    touch(): void;
+    stop(): void;
+    /** One liveness check; driven by the interval (public for tests). */
+    poll(): void;
+}
 /**
  * Consumes parsed stream events: renders live progress lines through
  * `onProgress` and accumulates the final outcome. `finish()` throws
@@ -58,9 +106,12 @@ export declare class AskStreamCollector {
     private terminal;
     private lastPhase;
     private toolNames;
+    private toolEvents;
     constructor(onProgress?: (line: string) => void);
     handle(raw: unknown): void;
     isTerminal(): boolean;
+    /** tool_start/tool_end events seen so far (fallback-heuristic input). */
+    get toolEventCount(): number;
     finish(): AskStreamOutcome;
 }
 /**
@@ -68,7 +119,12 @@ export declare class AskStreamCollector {
  * parser into the collector. Exported separately from `streamAsk` so tests can
  * exercise chunk-splitting behavior without a network layer.
  */
-export declare function consumeAskSse(chunks: AsyncIterable<Uint8Array | string>, collector: AskStreamCollector): Promise<AskStreamOutcome>;
+export declare function consumeAskSse(chunks: AsyncIterable<Uint8Array | string>, collector: AskStreamCollector, 
+/**
+ * Fires once per parsed `data:` event (keepalive comment frames never reach
+ * it). Used to reset the idle liveness ticker on real progress.
+ */
+onEvent?: () => void): Promise<AskStreamOutcome>;
 export interface StreamAskOptions {
     question: string;
     daysBack: number;

package/dist/ask-stream.js

@@ -16,11 +16,43 @@ import { resolveApiKey, resolveModaBaseUrl } from './config.js';
 import { stripAnsi } from './markdown-terminal.js';
 /** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
 export class AskStreamError extends Error {
+    /** Wall-clock ms the stream ran before failing (annotated by `streamAsk`). */
+    elapsedMs;
+    /** tool_start/tool_end events seen before failing (annotated by `streamAsk`). */
+    toolEvents;
     constructor(message) {
         super(message);
         this.name = 'AskStreamError';
     }
 }
+/**
+ * Thresholds for "substantial progress": a stream that ran at least this long,
+ * or produced more tool events than this, did real work before dropping —
+ * the buffered fallback then re-runs the WHOLE question, roughly doubling
+ * total latency, so the user deserves a notice instead of silence. The elapsed
+ * check is inclusive (`>=`) so a drop landing exactly on the boundary — where
+ * the doubled wait is felt most acutely — still gets the notice.
+ */
+export const SUBSTANTIAL_STREAM_PROGRESS_MS = 60_000;
+export const SUBSTANTIAL_STREAM_TOOL_EVENTS = 5;
+/**
+ * One-line stderr notice for a stream that died after substantial progress.
+ * Returns null for early failures (they keep today's silent fallback) and for
+ * non-stream errors. The caller still falls back either way — the user must
+ * still get an answer, just an informed wait instead of an apparent hang.
+ */
+export function streamFallbackNotice(error) {
+    if (!(error instanceof AskStreamError))
+        return null;
+    const elapsedMs = error.elapsedMs ?? 0;
+    const toolEvents = error.toolEvents ?? 0;
+    if (elapsedMs < SUBSTANTIAL_STREAM_PROGRESS_MS &&
+        toolEvents <= SUBSTANTIAL_STREAM_TOOL_EVENTS) {
+        return null;
+    }
+    return (`stream interrupted after ${Math.round(elapsedMs / 1000)}s; ` +
+        'retrying via buffered request — this may take another minute or two.');
+}
 /**
  * Incremental SSE frame parser. Feed decoded text chunks (arbitrarily split —
  * even mid `data:` line or mid multi-byte frame); complete `data:` payloads
@@ -74,6 +106,68 @@ function dataPayloadOf(frame) {
 }
 /** Phases worth a human status line (terminal/idle phases are omitted). */
 const RENDERED_PHASES = new Set(['planning', 'searching', 'analyzing', 'writing']);
+// ─── Idle liveness ticker ────────────────────────────────────
+/** Quiet period before the first liveness line is printed. */
+export const IDLE_TICKER_THRESHOLD_MS = 10_000;
+/** Minimum spacing between liveness lines. */
+export const IDLE_TICKER_MIN_UPDATE_MS = 15_000;
+const IDLE_TICKER_POLL_MS = 1_000;
+/**
+ * Client-side liveness for quiet stream periods: long tool-less LLM turns
+ * (coverage gate, synthesis) emit no events for 30–90s, which reads as a
+ * hang. Once no event has arrived for IDLE_TICKER_THRESHOLD_MS this prints an
+ * unobtrusive "… still working (Ns)" line (at most every
+ * IDLE_TICKER_MIN_UPDATE_MS) through the same progress channel as tool cards —
+ * stderr only, never interleaved into the final answer.
+ */
+export class IdleTicker {
+    write;
+    now;
+    startedAt;
+    lastEventAt;
+    lastPrintAt = 0;
+    timer;
+    constructor(write, now = Date.now) {
+        this.write = write;
+        this.now = now;
+        this.startedAt = this.now();
+        this.lastEventAt = this.startedAt;
+    }
+    start() {
+        if (this.timer)
+            return;
+        this.startedAt = this.now();
+        this.lastEventAt = this.startedAt;
+        this.timer = setInterval(() => this.poll(), IDLE_TICKER_POLL_MS);
+        // Never hold the process open for a liveness timer.
+        this.timer.unref?.();
+    }
+    /** Reset the idle clock — call on every real stream event. */
+    touch() {
+        this.lastEventAt = this.now();
+    }
+    stop() {
+        if (this.timer !== undefined)
+            clearInterval(this.timer);
+        this.timer = undefined;
+    }
+    /** One liveness check; driven by the interval (public for tests). */
+    poll() {
+        const at = this.now();
+        if (at - this.lastEventAt < IDLE_TICKER_THRESHOLD_MS)
+            return;
+        if (this.lastPrintAt !== 0 && at - this.lastPrintAt < IDLE_TICKER_MIN_UPDATE_MS)
+            return;
+        this.lastPrintAt = at;
+        const secs = Math.round((at - this.startedAt) / 1000);
+        try {
+            this.write(`… still working (${secs}s)`);
+        }
+        catch {
+            /* a liveness line must never break the stream */
+        }
+    }
+}
 /**
  * Consumes parsed stream events: renders live progress lines through
  * `onProgress` and accumulates the final outcome. `finish()` throws
@@ -92,6 +186,7 @@ export class AskStreamCollector {
     terminal = false;
     lastPhase;
     toolNames = new Map();
+    toolEvents = 0;
     constructor(onProgress = () => { }) {
         this.onProgress = onProgress;
     }
@@ -111,10 +206,22 @@ export class AskStreamCollector {
                 }
                 break;
             }
-            case 'thinking':
-                // Model narration is too chatty for one-line terminal progress; skip.
+            case 'thinking': {
+                // Model narration (`t<N>` ids) is too chatty for one-line terminal
+                // progress and stays hidden. Deliberation status lines the backend
+                // emits on purpose ('plan', 'gate-*': multi-part plan, coverage
+                // checks, nudge cycles) are concise and cover otherwise-silent LLM
+                // calls — render them like tool cards so the gate never reads as a hang.
+                const id = typeof event.id === 'string' ? event.id : '';
+                if (id === 'plan' || id.startsWith('gate-')) {
+                    const delta = typeof event.delta === 'string' ? event.delta : '';
+                    if (delta.trim().length > 0)
+                        this.onProgress(`◦ ${oneLine(delta)}`);
+                }
                 break;
+            }
             case 'tool_start': {
+                this.toolEvents += 1;
                 const tool = event.tool;
                 const id = typeof tool?.id === 'string' ? tool.id : '';
                 // Backend-controlled strings — strip ANSI so a rogue/compromised backend
@@ -127,6 +234,7 @@ export class AskStreamCollector {
                 break;
             }
             case 'tool_end': {
+                this.toolEvents += 1;
                 const id = typeof event.id === 'string' ? event.id : '';
                 const name = this.toolNames.get(id) ?? 'tool';
                 this.onProgress(`• ${name} — ${toolEndDetail(event)}`);
@@ -168,6 +276,10 @@ export class AskStreamCollector {
     isTerminal() {
         return this.terminal;
     }
+    /** tool_start/tool_end events seen so far (fallback-heuristic input). */
+    get toolEventCount() {
+        return this.toolEvents;
+    }
     finish() {
         if (!this.terminal) {
             throw new AskStreamError('stream ended before a terminal done/error event');
@@ -246,19 +358,26 @@ function normalizeStreamConfidence(value) {
  * parser into the collector. Exported separately from `streamAsk` so tests can
  * exercise chunk-splitting behavior without a network layer.
  */
-export async function consumeAskSse(chunks, collector) {
+export async function consumeAskSse(chunks, collector, 
+/**
+ * Fires once per parsed `data:` event (keepalive comment frames never reach
+ * it). Used to reset the idle liveness ticker on real progress.
+ */
+onEvent) {
     const parser = new SseParser();
     const decoder = new TextDecoder();
     for await (const chunk of chunks) {
         const text = typeof chunk === 'string' ? chunk : decoder.decode(chunk, { stream: true });
         for (const payload of parser.push(text)) {
             collector.handle(parsePayload(payload));
+            onEvent?.();
             if (collector.isTerminal())
                 return collector.finish();
         }
     }
     for (const payload of parser.flush()) {
         collector.handle(parsePayload(payload));
+        onEvent?.();
         if (collector.isTerminal())
             return collector.finish();
     }
@@ -284,6 +403,13 @@ export async function streamAsk(options) {
     const url = `${resolveModaBaseUrl(profileOptions)}/api/cli/ask/stream`;
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_STREAM_TIMEOUT_MS);
+    const startedAt = Date.now();
+    const onProgress = options.onProgress ?? (() => { });
+    const collector = new AskStreamCollector(onProgress);
+    // Liveness lines share the progress channel (stderr in the CLI), so they
+    // can never interleave into the final stdout answer.
+    const ticker = new IdleTicker(onProgress);
+    ticker.start();
     try {
         const fetchImpl = options.fetchImpl ?? fetch;
         let response;
@@ -318,9 +444,8 @@ export async function streamAsk(options) {
         if (!response.body) {
             throw new AskStreamError('stream response had no body');
         }
-        const collector = new AskStreamCollector(options.onProgress);
         try {
-            return await consumeAskSse(response.body, collector);
+            return await consumeAskSse(response.body, collector, () => ticker.touch());
         }
         catch (error) {
             if (error instanceof AskStreamError)
@@ -328,7 +453,20 @@ export async function streamAsk(options) {
             throw new AskStreamError(`stream read failed: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    catch (error) {
+        // Annotate stream failures with how far the run got, so the caller can
+        // decide between today's silent fallback (early drop) and an informed
+        // one (drop after substantial progress). See `streamFallbackNotice`.
+        if (error instanceof AskStreamError) {
+            if (error.elapsedMs === undefined)
+                error.elapsedMs = Date.now() - startedAt;
+            if (error.toolEvents === undefined)
+                error.toolEvents = collector.toolEventCount;
+        }
+        throw error;
+    }
     finally {
+        ticker.stop();
         clearTimeout(timeout);
     }
 }

package/dist/production-intelligence.d.ts

@@ -151,6 +151,8 @@ export declare function askModa(options: {
     daysBack: number;
     cwd: string;
     profile?: string;
+    /** Invoked if the POST hits a network fault and the one retry is used. */
+    onNetworkRetry?: () => void;
 }): Promise<ProductionAskResult>;
 /**
  * Whether `moda ask` should use the live SSE endpoint: only for a human

package/dist/production-intelligence.js

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { callControlAPI, callDataAPI } from './api-client.js';
-import { streamAsk } from './ask-stream.js';
+import { streamAsk, streamFallbackNotice } from './ask-stream.js';
 import { resolveModaBaseUrl } from './config.js';
 import { CliAuthError, CliInputError } from './errors.js';
 import { EXIT_DEGRADED, EXIT_OK, safeWriteStderr } from './output.js';
@@ -183,7 +183,16 @@ export async function askModa(options) {
                 profile: options.profile,
                 harness: localHarnessSummary(options.cwd),
             }),
-        }, options.profile ? { profile: options.profile } : {}, { timeoutMs: askTimeoutMs(), retries: 0 });
+        }, options.profile ? { profile: options.profile } : {}, {
+            timeoutMs: askTimeoutMs(),
+            retries: 0,
+            // A stream that just dropped can poison undici's pooled connection to
+            // this origin; without this the buffered fallback fails instantly at
+            // the transport level against a healthy backend. One retry, network
+            // faults only — HTTP errors and the run timeout still never retry.
+            retryOnceOnNetworkError: true,
+            onNetworkRetry: options.onNetworkRetry,
+        });
         const cloud = normalizeCloudAsk(response, options.question);
         if (cloud)
             return cloud;
@@ -264,8 +273,10 @@ export function shouldStreamAsk(context, isTTY = process.stdout.isTTY === true)
 async function askModaForContext(context, question, daysBack) {
     if (shouldStreamAsk(context)) {
         // Progress lines go to stderr, so key color off the stderr TTY. Tool cards
-        // (`• …`) are dimmed subtly; phase lines (`▸ …`) stay at full strength.
+        // (`• …`), deliberation lines (`◦ …`), and liveness ticks (`… …`) are
+        // dimmed subtly; phase lines (`▸ …`) stay at full strength.
         const progressStyle = terminalStyles(shouldColorTerminalOutput({ isTTY: process.stderr.isTTY === true }));
+        const dimmed = (line) => line.startsWith('•') || line.startsWith('◦') || line.startsWith('…');
         try {
             const outcome = await streamAsk({
                 question,
@@ -273,7 +284,7 @@ async function askModaForContext(context, question, daysBack) {
                 profile: context.profile,
                 harness: localHarnessSummary(context.cwd),
                 timeoutMs: askTimeoutMs(),
-                onProgress: (line) => safeWriteStderr(`${line.startsWith('•') ? progressStyle.dim(line) : line}\n`),
+                onProgress: (line) => safeWriteStderr(`${dimmed(line) ? progressStyle.dim(line) : line}\n`),
             });
             return askResultFromStreamOutcome(outcome, question);
         }
@@ -281,12 +292,26 @@ async function askModaForContext(context, question, daysBack) {
             // Auth problems must keep their structured exit-4 handling.
             if (error instanceof CliAuthError)
                 throw error;
-            if (context.verbose) {
+            const notice = streamFallbackNotice(error);
+            if (notice) {
+                // The stream died AFTER substantial visible progress: the buffered
+                // re-run roughly doubles the wait, so say so instead of going silent.
+                safeWriteStderr(`[moda] ${notice}\n`);
+            }
+            else if (context.verbose) {
                 safeWriteStderr(`[moda] live progress unavailable (${error instanceof Error ? error.message : String(error)}); using buffered ask.\n`);
             }
         }
     }
-    return askModa({ question, daysBack, cwd: context.cwd, profile: context.profile });
+    return askModa({
+        question,
+        daysBack,
+        cwd: context.cwd,
+        profile: context.profile,
+        onNetworkRetry: context.verbose
+            ? () => safeWriteStderr('[moda] network hiccup reaching Moda Cloud; retrying the buffered ask once…\n')
+            : undefined,
+    });
 }
 /**
  * Project a completed stream into the same `ProductionAskResult` the buffered

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.16.0",
+  "version": "1.17.0",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-07-08T20:47:23.985Z",
-  "cli_version": "1.16.0",
+  "bundled_at": "2026-07-08T22:14:49.889Z",
+  "cli_version": "1.17.0",
   "skills": [
     {
       "id": "integration-node-anthropic",