@moda-ai/cli 1.13.10 → 1.14.0

package/README.md

@@ -58,9 +58,6 @@ moda tool-failures                               # Tool failure overview
 moda tool-failure-detail <tool_name>             # Per-tool failure detail
 moda tool-failure-detail <tool_name> --include-window --window=1
 
-moda loops                                       # Currently-active loop detections
-moda loop <detection_id>                         # One loop detail (signature + blast radius)
-
 # Prompt management
 moda prompts init                                # Create .moda/prompts.yml
 moda prompts status                              # Read-only local prompt status
@@ -75,7 +72,6 @@ All commands output JSON. Pipe to `jq` for filtering:
 ```bash
 moda overview | jq '.frustrations'
 moda frustrations | jq '.frustrations[].primary_cause'
-moda loops | jq '.loops | sort_by(-.cycle_visits) | .[0:5] | .[].loop_signature_human'
 ```
 
 ## Prompt Management

package/dist/agent-schemas.js

@@ -224,7 +224,7 @@ const productionEvidenceRefSchema = {
         id: { type: 'string' },
         kind: {
             type: 'string',
-            enum: ['data_api', 'tool_failure', 'frustration', 'loop', 'run', 'harness', 'ask'],
+            enum: ['data_api', 'tool_failure', 'frustration', 'run', 'harness', 'ask'],
         },
         label: { type: 'string' },
         endpoint: { type: 'string' },
@@ -284,7 +284,6 @@ const productionFindingSchema = {
             type: 'string',
             enum: [
                 'tool_failure',
-                'loop',
                 'frustration',
                 'partial_run',
                 'prompt_regression',

package/dist/ask-stream.d.ts

@@ -0,0 +1,90 @@
+import type { AgentConfidence } from './output.js';
+/** Mirrors backend `AgentPhase`. */
+export type AskStreamPhase = 'idle' | 'planning' | 'searching' | 'analyzing' | 'writing' | 'done' | 'error' | 'stopped';
+/** Mirrors backend `StreamCitation`. */
+export interface AskStreamCitation {
+    id: string;
+    n: number;
+    label: string;
+    source: string;
+    snippet?: string;
+    href?: string;
+}
+/** Everything the CLI needs from a completed stream to render the final answer. */
+export interface AskStreamOutcome {
+    answer: string;
+    confidence: AgentConfidence;
+    citations: AskStreamCitation[];
+    nextCommands: string[];
+    elapsedMs?: number;
+    /**
+     * Set when the stream terminated with a terminal `error` event (the agent
+     * failed server-side). Transport failures throw `AskStreamError` instead.
+     */
+    errorMessage?: string;
+}
+/** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
+export declare class AskStreamError extends Error {
+    constructor(message: string);
+}
+/**
+ * Incremental SSE frame parser. Feed decoded text chunks (arbitrarily split —
+ * even mid `data:` line or mid multi-byte frame); complete `data:` payloads
+ * are returned in order. Handles LF and CRLF framing, multi-line `data:`
+ * fields, and ignores comments (`: ...`) and non-data fields (`event:`, `id:`).
+ */
+export declare class SseParser {
+    private buffer;
+    private pendingCr;
+    push(chunk: string): string[];
+    /** Drain a final frame that was not terminated by a blank line. */
+    flush(): string[];
+}
+/**
+ * Consumes parsed stream events: renders live progress lines through
+ * `onProgress` and accumulates the final outcome. `finish()` throws
+ * `AskStreamError` unless a terminal event (`done` or `error`) arrived, so a
+ * connection dropped mid-run triggers the buffered fallback instead of
+ * rendering a truncated answer.
+ */
+export declare class AskStreamCollector {
+    private readonly onProgress;
+    private answer;
+    private confidence;
+    private citations;
+    private nextCommands;
+    private elapsedMs;
+    private errorMessage;
+    private terminal;
+    private lastPhase;
+    private toolNames;
+    constructor(onProgress?: (line: string) => void);
+    handle(raw: unknown): void;
+    isTerminal(): boolean;
+    finish(): AskStreamOutcome;
+}
+/**
+ * Iterate any chunk source (a fetch body, or test fixtures) through the SSE
+ * 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 interface StreamAskOptions {
+    question: string;
+    daysBack: number;
+    profile?: string;
+    harness?: Record<string, unknown> | null;
+    /** Overall wall-clock budget for the run (default 250s, like buffered ask). */
+    timeoutMs?: number;
+    onProgress?: (line: string) => void;
+    /** Test seam. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * POST the question to `/api/cli/ask/stream` and consume the SSE response.
+ * Throws `AskStreamError` on any transport/framing problem (non-2xx, wrong
+ * content type, network drop, truncated stream) so callers can fall back to
+ * the buffered endpoint.
+ */
+export declare function streamAsk(options: StreamAskOptions): Promise<AskStreamOutcome>;
+//# sourceMappingURL=ask-stream.d.ts.map

package/dist/ask-stream.js

@@ -0,0 +1,330 @@
+// src/ask-stream.ts
+//
+// SSE consumer for `POST /api/cli/ask/stream` (the backend's streaming ask
+// endpoint). Mirrors the `AgentStreamEvent` wire protocol defined in
+// apps/moda-backend/src/data-agent/agent/stream-events.ts: SSE frames of
+// `data: <json>` carrying phase / thinking / tool_start / tool_end / sources /
+// text / done / error events.
+//
+// Design contract: ANY transport, framing, or protocol problem throws
+// `AskStreamError` so the caller can transparently fall back to the buffered
+// `POST /api/cli/ask` path — a user must never get a worse outcome than the
+// buffered request. A terminal `error` event from the agent is NOT a transport
+// failure: it is returned as an outcome (`errorMessage`) and rendered the same
+// way buffered agent errors render.
+import { resolveApiKey, resolveModaBaseUrl } from './config.js';
+/** Signals "fall back to the buffered ask endpoint" — never surfaced raw. */
+export class AskStreamError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AskStreamError';
+    }
+}
+/**
+ * Incremental SSE frame parser. Feed decoded text chunks (arbitrarily split —
+ * even mid `data:` line or mid multi-byte frame); complete `data:` payloads
+ * are returned in order. Handles LF and CRLF framing, multi-line `data:`
+ * fields, and ignores comments (`: ...`) and non-data fields (`event:`, `id:`).
+ */
+export class SseParser {
+    buffer = '';
+    pendingCr = false;
+    push(chunk) {
+        let text = (this.pendingCr ? '\r' : '') + chunk;
+        this.pendingCr = false;
+        // Hold back a trailing '\r' — it may be half of a CRLF split across chunks.
+        if (text.endsWith('\r')) {
+            this.pendingCr = true;
+            text = text.slice(0, -1);
+        }
+        this.buffer += text.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+        const payloads = [];
+        let boundary = this.buffer.indexOf('\n\n');
+        while (boundary !== -1) {
+            const frame = this.buffer.slice(0, boundary);
+            this.buffer = this.buffer.slice(boundary + 2);
+            const payload = dataPayloadOf(frame);
+            if (payload !== null)
+                payloads.push(payload);
+            boundary = this.buffer.indexOf('\n\n');
+        }
+        return payloads;
+    }
+    /** Drain a final frame that was not terminated by a blank line. */
+    flush() {
+        const remaining = this.buffer + (this.pendingCr ? '\r' : '');
+        this.buffer = '';
+        this.pendingCr = false;
+        const payload = dataPayloadOf(remaining.replace(/\r\n/g, '\n').replace(/\r/g, '\n'));
+        return payload !== null ? [payload] : [];
+    }
+}
+function dataPayloadOf(frame) {
+    const dataLines = [];
+    for (const line of frame.split('\n')) {
+        if (line.startsWith('data:')) {
+            dataLines.push(line.slice(5).replace(/^ /, ''));
+        }
+    }
+    if (dataLines.length === 0)
+        return null;
+    const payload = dataLines.join('\n');
+    return payload.trim().length > 0 ? payload : null;
+}
+/** Phases worth a human status line (terminal/idle phases are omitted). */
+const RENDERED_PHASES = new Set(['planning', 'searching', 'analyzing', 'writing']);
+/**
+ * Consumes parsed stream events: renders live progress lines through
+ * `onProgress` and accumulates the final outcome. `finish()` throws
+ * `AskStreamError` unless a terminal event (`done` or `error`) arrived, so a
+ * connection dropped mid-run triggers the buffered fallback instead of
+ * rendering a truncated answer.
+ */
+export class AskStreamCollector {
+    onProgress;
+    answer = '';
+    confidence = 'medium';
+    citations = [];
+    nextCommands = [];
+    elapsedMs;
+    errorMessage;
+    terminal = false;
+    lastPhase;
+    toolNames = new Map();
+    constructor(onProgress = () => { }) {
+        this.onProgress = onProgress;
+    }
+    handle(raw) {
+        if (this.terminal)
+            return;
+        const event = raw;
+        if (!event || typeof event !== 'object' || typeof event.type !== 'string') {
+            throw new AskStreamError('stream emitted a frame without an event type');
+        }
+        switch (event.type) {
+            case 'phase': {
+                const phase = typeof event.phase === 'string' ? event.phase : '';
+                if (RENDERED_PHASES.has(phase) && phase !== this.lastPhase) {
+                    this.lastPhase = phase;
+                    this.onProgress(`▸ ${phase}…`);
+                }
+                break;
+            }
+            case 'thinking':
+                // Model narration is too chatty for one-line terminal progress; skip.
+                break;
+            case 'tool_start': {
+                const tool = event.tool;
+                const id = typeof tool?.id === 'string' ? tool.id : '';
+                const name = typeof tool?.tool === 'string' ? tool.tool : 'tool';
+                const title = typeof tool?.title === 'string' ? tool.title : name;
+                if (id)
+                    this.toolNames.set(id, name);
+                this.onProgress(`• ${name} — ${title}…`);
+                break;
+            }
+            case 'tool_end': {
+                const id = typeof event.id === 'string' ? event.id : '';
+                const name = this.toolNames.get(id) ?? 'tool';
+                this.onProgress(`• ${name} — ${toolEndDetail(event)}`);
+                break;
+            }
+            case 'sources': {
+                this.citations = Array.isArray(event.citations)
+                    ? event.citations.flatMap(normalizeCitation)
+                    : [];
+                break;
+            }
+            case 'text': {
+                if (typeof event.delta === 'string')
+                    this.answer += event.delta;
+                break;
+            }
+            case 'done': {
+                this.terminal = true;
+                this.confidence = normalizeStreamConfidence(event.confidence);
+                if (typeof event.elapsedMs === 'number')
+                    this.elapsedMs = event.elapsedMs;
+                this.nextCommands = Array.isArray(event.nextCommands)
+                    ? event.nextCommands.filter((item) => typeof item === 'string')
+                    : [];
+                break;
+            }
+            case 'error': {
+                this.terminal = true;
+                this.errorMessage = typeof event.message === 'string' && event.message.trim().length > 0
+                    ? event.message
+                    : 'The analysis agent hit an error and could not complete the request.';
+                break;
+            }
+            default:
+                // Forward-compatible: unknown event types are ignored, not fatal.
+                break;
+        }
+    }
+    isTerminal() {
+        return this.terminal;
+    }
+    finish() {
+        if (!this.terminal) {
+            throw new AskStreamError('stream ended before a terminal done/error event');
+        }
+        if (!this.errorMessage && this.answer.trim().length === 0) {
+            // Mirror the buffered contract: an empty answer means "no usable cloud
+            // answer" and must trigger the fallback path, not render as blank prose.
+            throw new AskStreamError('stream completed with an empty answer');
+        }
+        return {
+            answer: this.answer,
+            confidence: this.confidence,
+            citations: this.citations,
+            nextCommands: this.nextCommands,
+            ...(this.elapsedMs !== undefined ? { elapsedMs: this.elapsedMs } : {}),
+            ...(this.errorMessage ? { errorMessage: this.errorMessage } : {}),
+        };
+    }
+}
+/**
+ * Tool cards must stay one line: backend summaries can be multi-line prose
+ * (e.g. get_timeseries emits a day-by-day breakdown), which would spill the
+ * whole table into the progress area. Collapse whitespace and truncate.
+ */
+const TOOL_CARD_DETAIL_MAX = 100;
+function oneLine(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > TOOL_CARD_DETAIL_MAX
+        ? `${collapsed.slice(0, TOOL_CARD_DETAIL_MAX - 1)}…`
+        : collapsed;
+}
+function toolEndDetail(event) {
+    const summary = typeof event.summary === 'string' ? event.summary : '';
+    const secs = typeof event.ms === 'number' ? `${(event.ms / 1000).toFixed(1)}s` : undefined;
+    if (event.status === 'error') {
+        const reason = typeof event.error === 'string' && event.error ? event.error : summary || 'failed';
+        return joinDetail(`failed: ${oneLine(reason)}`, secs);
+    }
+    const detail = summary ||
+        (typeof event.hits === 'number'
+            ? `${event.hits} hits`
+            : typeof event.rows === 'number'
+                ? `${event.rows} rows`
+                : 'done');
+    return joinDetail(oneLine(detail), secs);
+}
+function joinDetail(detail, secs) {
+    return secs ? `${detail}, ${secs}` : detail;
+}
+function normalizeCitation(item) {
+    const record = item;
+    if (!record || typeof record !== 'object')
+        return [];
+    const label = typeof record.label === 'string' ? record.label : undefined;
+    const id = typeof record.id === 'string' ? record.id : undefined;
+    if (!label && !id)
+        return [];
+    return [{
+            id: id ?? `ref-${typeof record.n === 'number' ? record.n : 0}`,
+            n: typeof record.n === 'number' ? record.n : 0,
+            label: label ?? id ?? 'Cloud evidence',
+            source: typeof record.source === 'string' ? record.source : 'evidence',
+            ...(typeof record.snippet === 'string' ? { snippet: record.snippet } : {}),
+            ...(typeof record.href === 'string' ? { href: record.href } : {}),
+        }];
+}
+function normalizeStreamConfidence(value) {
+    return value === 'high' || value === 'medium' || value === 'low' || value === 'unknown'
+        ? value
+        : 'medium';
+}
+/**
+ * Iterate any chunk source (a fetch body, or test fixtures) through the SSE
+ * 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) {
+    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));
+            if (collector.isTerminal())
+                return collector.finish();
+        }
+    }
+    for (const payload of parser.flush()) {
+        collector.handle(parsePayload(payload));
+        if (collector.isTerminal())
+            return collector.finish();
+    }
+    return collector.finish();
+}
+function parsePayload(payload) {
+    try {
+        return JSON.parse(payload);
+    }
+    catch {
+        throw new AskStreamError('stream emitted an unparseable frame');
+    }
+}
+const DEFAULT_STREAM_TIMEOUT_MS = 250_000;
+/**
+ * POST the question to `/api/cli/ask/stream` and consume the SSE response.
+ * Throws `AskStreamError` on any transport/framing problem (non-2xx, wrong
+ * content type, network drop, truncated stream) so callers can fall back to
+ * the buffered endpoint.
+ */
+export async function streamAsk(options) {
+    const profileOptions = options.profile ? { profile: options.profile } : {};
+    const url = `${resolveModaBaseUrl(profileOptions)}/api/cli/ask/stream`;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? DEFAULT_STREAM_TIMEOUT_MS);
+    try {
+        const fetchImpl = options.fetchImpl ?? fetch;
+        let response;
+        try {
+            response = await fetchImpl(url, {
+                method: 'POST',
+                headers: {
+                    'x-api-key': resolveApiKey(profileOptions) ?? '',
+                    'Content-Type': 'application/json',
+                    Accept: 'text/event-stream',
+                },
+                body: JSON.stringify({
+                    question: options.question,
+                    daysBack: options.daysBack,
+                    profile: options.profile,
+                    harness: options.harness,
+                }),
+                signal: controller.signal,
+            });
+        }
+        catch (error) {
+            throw new AskStreamError(`stream request failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (!response.ok) {
+            throw new AskStreamError(`stream endpoint returned HTTP ${response.status}`);
+        }
+        const contentType = response.headers.get('content-type') ?? '';
+        if (!contentType.includes('text/event-stream')) {
+            // An old frontend deploy without the stream proxy can 200 with JSON/HTML.
+            throw new AskStreamError(`stream endpoint returned unexpected content type '${contentType || 'unknown'}'`);
+        }
+        if (!response.body) {
+            throw new AskStreamError('stream response had no body');
+        }
+        const collector = new AskStreamCollector(options.onProgress);
+        try {
+            return await consumeAskSse(response.body, collector);
+        }
+        catch (error) {
+            if (error instanceof AskStreamError)
+                throw error;
+            throw new AskStreamError(`stream read failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+//# sourceMappingURL=ask-stream.js.map

package/dist/cli.js

@@ -2,7 +2,7 @@
 import { z } from 'zod';
 import { validateConfig, VERSION, resolveApiKey } from './config.js';
 import { callDataAPI, ApiError, getApiRequestCount, resetApiRequestCount, } from './api-client.js';
-import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, SearchSchema, WorldStateSchema, ContextSchema, AuditSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, LoopsSchema, LoopDetailSchema, } from './schemas.js';
+import { OverviewSchema, ClustersSchema, ClusterConversationsSchema, ConversationsSchema, SearchSchema, WorldStateSchema, ContextSchema, AuditSchema, FrustrationsSchema, ToolFailuresSchema, ToolFailureDetailSchema, } from './schemas.js';
 import { withFrustrationAnchors, withToolFailureAnchors, embeddedWindowSize, asRecord, asString, asNumber } from './transforms.js';
 import { runPromptsCommand } from './prompts.js';
 // Coding-agent capture (shadow workspace / Shadow Spark / trace hooks) is temporarily
@@ -171,9 +171,6 @@ Commands:
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
 
-  loops                            Currently-active loop detections
-  loop <detection_id>              Single loop detail
-
   Prompt management:
   prompts init                     Create .moda/prompts.yml
   prompts status                   Show local prompt changes
@@ -206,6 +203,7 @@ Common flags:
   --agent                          Emit schema-versioned agent JSON
   --stream                         With --agent, emit NDJSON agent events
   --human                          Force human prose (overrides auto-detection)
+  --no-stream                      Disable live ask progress (buffered request)
 
 Output auto-detection (no flags needed):
   Piped/redirected stdout, CI, or an agent env (CLAUDECODE/CURSOR/MODA_AGENT)
@@ -306,8 +304,6 @@ Examples:
   moda context <conversation_id> --window=3
   moda audit <conversation_id|trace_id>
   moda audit <trace_id> --kind=trace --json
-  moda loops --limit=10
-  moda loop 12345678-1234-1234-1234-1234567890ab
   moda prompts status
   moda prompts sync
   moda prompts promote support.triage --label=prod --version=pver_abc123
@@ -617,27 +613,6 @@ export async function runCommand(command, positional, flags, positionals = posit
             await printWithOptionalWindows(withToolFailureAnchors(data), 'examples', params.include_window === true, params.window ?? 1, context.output);
             break;
         }
-        case 'loops': {
-            const args = flagsToArgs(flags);
-            const params = LoopsSchema.parse(args);
-            const query = new URLSearchParams();
-            if (params.limit)
-                query.set('limit', params.limit.toString());
-            const queryString = query.toString() ? `?${query.toString()}` : '';
-            const data = await callDataAPI(`/loops/active${queryString}`);
-            context.output.writeData(data);
-            break;
-        }
-        case 'loop': {
-            if (!positional) {
-                throw new CliInputError('<detection_id> is required', 'Usage: moda loop <detection_id>');
-            }
-            const args = flagsToArgs(flags, 'detection_id', positional);
-            const params = LoopDetailSchema.parse(args);
-            const data = await callDataAPI(`/loops/${params.detection_id}`);
-            context.output.writeData(data);
-            break;
-        }
         default:
             throw new CliInputError(`Unknown command '${command}'`, 'Run "moda --help" for usage information.');
     }
@@ -966,7 +941,11 @@ export const commandRegistry = createCommandRegistry([
     legacyCommand({
         name: 'ask',
         description: 'Ask Moda a production intelligence question',
-        examples: ['moda ask "what should I fix first?"', 'moda --agent ask "why did this run fail?"'],
+        examples: [
+            'moda ask "what should I fix first?"',
+            'moda ask "what should I fix first?" --no-stream',
+            'moda --agent ask "why did this run fail?"',
+        ],
         ...dataApiDefaults,
     }),
     legacyCommand({
@@ -1044,18 +1023,6 @@ export const commandRegistry = createCommandRegistry([
         examples: ['moda tool-failure-detail search --include-window'],
         ...dataApiDefaults,
     }),
-    legacyCommand({
-        name: 'loops',
-        description: 'List currently-active loop detections',
-        examples: ['moda loops --limit=10'],
-        ...dataApiDefaults,
-    }),
-    legacyCommand({
-        name: 'loop',
-        description: 'Get a single loop detection',
-        examples: ['moda loop 12345678-1234-1234-1234-1234567890ab'],
-        ...dataApiDefaults,
-    }),
     legacyCommand({
         name: 'prompts',
         description: 'Manage prompt versions and labels',

package/dist/production-intelligence.d.ts

@@ -1,3 +1,4 @@
+import { type AskStreamOutcome } from './ask-stream.js';
 import type { CommandContext } from './command-context.js';
 import type { AgentConfidence } from './output.js';
 import { type ModaIntelligenceV1 } from './intelligence-schema.js';
@@ -5,10 +6,10 @@ declare const INVESTIGATION_SCHEMA_VERSION = "production_investigation.v0.1";
 declare const OVERVIEW_SCHEMA_VERSION = "production_overview.v0.1";
 declare const ASK_SCHEMA_VERSION = "production_ask.v0.1";
 type Severity = 'critical' | 'high' | 'medium' | 'low' | 'info';
-type FindingKind = 'tool_failure' | 'loop' | 'frustration' | 'prompt_regression' | 'skill_gap' | 'insufficient_data';
+type FindingKind = 'tool_failure' | 'frustration' | 'prompt_regression' | 'skill_gap' | 'insufficient_data';
 export interface ProductionEvidenceRef {
     id: string;
-    kind: 'data_api' | 'tool_failure' | 'frustration' | 'loop' | 'harness' | 'ask';
+    kind: 'data_api' | 'tool_failure' | 'frustration' | 'harness' | 'ask';
     label: string;
     endpoint?: string;
     conversationId?: string;
@@ -54,7 +55,6 @@ export interface ProductionInvestigation {
     scope: {
         conversationId?: string;
         toolName?: string;
-        loopId?: string;
         question?: string;
     };
     summary: {
@@ -137,7 +137,6 @@ export declare function investigateProduction(options: {
     cwd: string;
     conversationId?: string;
     toolName?: string;
-    loopId?: string;
     question?: string;
     failureOnly?: boolean;
 }): Promise<ProductionInvestigation>;
@@ -147,5 +146,20 @@ export declare function askModa(options: {
     cwd: string;
     profile?: string;
 }): Promise<ProductionAskResult>;
+/**
+ * Whether `moda ask` should use the live SSE endpoint: only for a human
+ * watching a TTY, and only when not explicitly opted out via `--no-stream`
+ * (or `--stream=false`). `--json`/`--agent`/piped/quiet callers always take
+ * the buffered path so machine-readable contracts are untouched.
+ */
+export declare function shouldStreamAsk(context: Pick<CommandContext, 'outputMode' | 'quiet' | 'flags'>, isTTY?: boolean): boolean;
+/**
+ * Project a completed stream into the same `ProductionAskResult` the buffered
+ * path produces, so the final human render is identical. A terminal `error`
+ * event mirrors the buffered error contract (a generic answer with `unknown`
+ * confidence — the buffered endpoint also returns HTTP 200 in that case).
+ */
+export declare function askResultFromStreamOutcome(outcome: AskStreamOutcome, question: string): ProductionAskResult;
+export declare function renderAskHuman(result: ProductionAskResult): string;
 export {};
 //# sourceMappingURL=production-intelligence.d.ts.map

package/dist/production-intelligence.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { callControlAPI, callDataAPI } from './api-client.js';
-import { CliInputError } from './errors.js';
-import { EXIT_DEGRADED, EXIT_OK } from './output.js';
+import { streamAsk } from './ask-stream.js';
+import { CliAuthError, CliInputError } from './errors.js';
+import { EXIT_DEGRADED, EXIT_OK, safeWriteStderr } from './output.js';
 import { asNumber, asRecord, asString } from './transforms.js';
 import { INTELLIGENCE_SCHEMA_VERSION, } from './intelligence-schema.js';
 const INVESTIGATION_SCHEMA_VERSION = 'production_investigation.v0.1';
@@ -32,7 +33,7 @@ export async function runProductionCommand(context) {
         if (!question) {
             throw new CliInputError('<question> is required', 'Usage: moda ask "what should I fix first?" [--days-back=N]');
         }
-        const result = await askModa({ question, daysBack, cwd: context.cwd, profile: context.profile });
+        const result = await askModaForContext(context, question, daysBack);
         if (context.outputMode === 'human') {
             if (!context.quiet)
                 console.log(renderAskHuman(result));
@@ -66,7 +67,6 @@ export async function runProductionCommand(context) {
             cwd: context.cwd,
             conversationId: context.flags.conversation,
             toolName: context.flags.tool,
-            loopId: context.flags.loop,
         });
         writeInvestigation(context, investigation);
         return { exitCode: 0 };
@@ -127,16 +127,12 @@ export async function investigateProduction(options) {
         ? `/tool-failures/${encodeURIComponent(options.toolName)}?days_back=${options.daysBack}&limit=5`
         : `/tool-failures?days_back=${options.daysBack}`;
     const frustrationsEndpoint = `/frustrations?days_back=${options.daysBack}&limit=5`;
-    const loopsEndpoint = options.loopId
-        ? `/loops/${encodeURIComponent(options.loopId)}`
-        : '/loops/active?limit=20';
-    const [overview, tools, frustrations, loops] = await Promise.all([
+    const [overview, tools, frustrations] = await Promise.all([
         safeData(overviewEndpoint),
         safeData(toolEndpoint),
         safeData(frustrationsEndpoint),
-        safeData(loopsEndpoint),
     ]);
-    for (const [key, result] of Object.entries({ overview, tools, frustrations, loops })) {
+    for (const [key, result] of Object.entries({ overview, tools, frustrations })) {
         sourceStatus[key] = result.status;
         if (result.warning)
             warnings.push(result.warning);
@@ -147,10 +143,6 @@ export async function investigateProduction(options) {
     findings.push(...toolFailureFindings(tools.data, options.daysBack, hints, evidenceRefs, options.toolName));
     if (!options.failureOnly) {
         findings.push(...frustrationFindings(frustrations.data, options.daysBack, evidenceRefs));
-        findings.push(...loopFindings(loops.data, evidenceRefs, options.loopId));
-    }
-    else {
-        findings.push(...loopFindings(loops.data, evidenceRefs, options.loopId));
     }
     if (findings.length === 0) {
         findings.push(insufficientDataFinding(overview.data, evidenceRefs));
@@ -165,7 +157,6 @@ export async function investigateProduction(options) {
         scope: {
             ...(options.conversationId ? { conversationId: options.conversationId } : {}),
             ...(options.toolName ? { toolName: options.toolName } : {}),
-            ...(options.loopId ? { loopId: options.loopId } : {}),
             ...(options.question ? { question: options.question } : {}),
         },
         summary: summarizeInvestigation(boundedFindings),
@@ -246,6 +237,98 @@ export async function askModa(options) {
         }),
     };
 }
+/**
+ * Whether `moda ask` should use the live SSE endpoint: only for a human
+ * watching a TTY, and only when not explicitly opted out via `--no-stream`
+ * (or `--stream=false`). `--json`/`--agent`/piped/quiet callers always take
+ * the buffered path so machine-readable contracts are untouched.
+ */
+export function shouldStreamAsk(context, isTTY = process.stdout.isTTY === true) {
+    if (context.outputMode !== 'human' || context.quiet)
+        return false;
+    if ('no-stream' in context.flags)
+        return false;
+    if (context.flags.stream === 'false')
+        return false;
+    return isTTY;
+}
+/**
+ * Human-TTY ask entrypoint: try the streaming endpoint for live progress and
+ * fall back to the buffered `askModa` on ANY stream problem (endpoint missing,
+ * connection dropped mid-run, framing error). The fallback is transparent —
+ * a note is printed only in verbose mode — so the outcome is never worse than
+ * the buffered path.
+ */
+async function askModaForContext(context, question, daysBack) {
+    if (shouldStreamAsk(context)) {
+        try {
+            const outcome = await streamAsk({
+                question,
+                daysBack,
+                profile: context.profile,
+                harness: localHarnessSummary(context.cwd),
+                timeoutMs: askTimeoutMs(),
+                onProgress: (line) => safeWriteStderr(`${line}\n`),
+            });
+            return askResultFromStreamOutcome(outcome, question);
+        }
+        catch (error) {
+            // Auth problems must keep their structured exit-4 handling.
+            if (error instanceof CliAuthError)
+                throw error;
+            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 });
+}
+/**
+ * Project a completed stream into the same `ProductionAskResult` the buffered
+ * path produces, so the final human render is identical. A terminal `error`
+ * event mirrors the buffered error contract (a generic answer with `unknown`
+ * confidence — the buffered endpoint also returns HTTP 200 in that case).
+ */
+export function askResultFromStreamOutcome(outcome, question) {
+    const answer = outcome.errorMessage ?? outcome.answer;
+    const confidence = outcome.errorMessage
+        ? 'unknown'
+        : normalizeConfidence(outcome.confidence);
+    const evidenceRefs = outcome.errorMessage
+        ? []
+        : outcome.citations.map((citation) => ({
+            id: citation.id,
+            kind: evidenceKind(citation.source),
+            label: citation.label,
+        }));
+    const nextCommands = outcome.errorMessage ? [] : outcome.nextCommands;
+    const warnings = outcome.errorMessage
+        ? ['The analysis agent failed; returning a generic message.']
+        : [];
+    return {
+        schemaVersion: ASK_SCHEMA_VERSION,
+        generatedAt: new Date().toISOString(),
+        source: 'cloud',
+        degraded: false,
+        question,
+        answer,
+        confidence,
+        evidenceRefs,
+        findings: [],
+        nextCommands,
+        warnings,
+        intelligence: synthesizeIntelligenceV1({
+            question,
+            answer,
+            confidence,
+            evidenceRefs,
+            nextCommands,
+            warnings,
+            source: 'cloud',
+            degraded: false,
+        }),
+    };
+}
 /**
  * Timeout (ms) for the cloud `ask` POST. The backend enforces its own ~240s run
  * deadline under a 300s function limit, so the client waits long enough to
@@ -444,44 +527,6 @@ function frustrationFindings(data, daysBack, evidenceRefs) {
                 }],
         }];
 }
-function loopFindings(data, evidenceRefs, scopedLoopId) {
-    const rows = loopRows(data);
-    return rows.flatMap((loop) => {
-        const id = loop.id || scopedLoopId;
-        if (!id)
-            return [];
-        const evidenceId = `loop:${id}`;
-        evidenceRefs.push({
-            id: evidenceId,
-            kind: 'loop',
-            label: loop.signature || `${loop.type || 'Loop'} detected`,
-            endpoint: `/loops/${id}`,
-            detectionId: id,
-            conversationId: loop.conversationId,
-            value: loop.raw,
-        });
-        return [{
-                id: `finding_loop_${slug(id)}`,
-                kind: 'loop',
-                title: loop.signature || `${loop.type || 'Loop'} detected`,
-                severity: loop.blastRadius >= 5 ? 'high' : 'medium',
-                confidence: 'high',
-                impactScore: 84 + Math.min(loop.blastRadius, 10),
-                rankReason: `Active loop detection${loop.blastRadius ? ` with blast radius ${loop.blastRadius}` : ''}.`,
-                summary: loop.rootCause || 'The agent appears to repeat work or retry a failing path.',
-                evidenceRefIds: [evidenceId],
-                likelyLocations: [unknownLocation('prompt', 'Loops often come from retry policy, stop conditions, or tool handling.')],
-                recommendedActions: [{
-                        id: `action_loop_${slug(id)}`,
-                        title: 'Inspect loop detail.',
-                        rationale: 'Loop detail includes signature, cycle length, and root-cause hypothesis.',
-                        command: `moda loop ${id}`,
-                        mutability: 'read',
-                        requiresApproval: false,
-                    }],
-            }];
-    });
-}
 function insufficientDataFinding(overview, evidenceRefs) {
     const evidenceId = 'overview:data';
     if (!evidenceRefs.some((ref) => ref.id === evidenceId)) {
@@ -974,7 +1019,7 @@ function renderInvestigationHuman(investigation) {
     }
     return lines.join('\n');
 }
-function renderAskHuman(result) {
+export function renderAskHuman(result) {
     const lines = [];
     lines.push('Moda ask');
     lines.push(`Question: ${result.question}`);
@@ -1060,28 +1105,6 @@ function toolRows(data, scopedTool) {
             }];
     });
 }
-function loopRows(data) {
-    const record = asRecord(data);
-    const rows = Array.isArray(record?.loops)
-        ? record.loops
-        : asRecord(record)
-            ? [record]
-            : [];
-    return rows.flatMap((item) => {
-        const row = asRecord(item);
-        if (!row)
-            return [];
-        return [{
-                id: asString(row.detection_id) ?? '',
-                type: asString(row.loop_type) ?? undefined,
-                signature: asString(row.loop_signature_human) ?? undefined,
-                blastRadius: numberValue(row.blast_radius),
-                conversationId: asString(row.conversation_id) ?? undefined,
-                rootCause: asString(row.root_cause_hypothesis) ?? undefined,
-                raw: row,
-            }];
-    }).filter((loop) => loop.id);
-}
 function firstQuote(row) {
     const quotes = Array.isArray(row?.user_quotes) ? row.user_quotes : [];
     const first = asRecord(quotes[0]);
@@ -1335,7 +1358,6 @@ function evidenceKind(value) {
     if (value === 'data_api' ||
         value === 'tool_failure' ||
         value === 'frustration' ||
-        value === 'loop' ||
         value === 'harness' ||
         value === 'ask')
         return value;
@@ -1355,8 +1377,6 @@ function purposeForCommand(command) {
         return 'Inspect tool failure examples and conversation anchors.';
     if (command.startsWith('moda context'))
         return 'Read the relevant conversation window.';
-    if (command.startsWith('moda loop'))
-        return 'Inspect loop detection details.';
     if (command.startsWith('moda doctor'))
         return 'Validate Moda setup and data flow.';
     if (command.startsWith('moda overview'))

package/dist/schemas.d.ts

@@ -185,20 +185,4 @@ export declare const SearchSchema: z.ZodObject<{
     limit?: number | undefined;
     user_id?: string | undefined;
 }>;
-/** moda loops — currently active loop detections. */
-export declare const LoopsSchema: z.ZodObject<{
-    limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
-}, "strip", z.ZodTypeAny, {
-    limit?: number | undefined;
-}, {
-    limit?: number | undefined;
-}>;
-/** moda loop <detectionId> — single loop detection detail. */
-export declare const LoopDetailSchema: z.ZodObject<{
-    detection_id: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    detection_id: string;
-}, {
-    detection_id: string;
-}>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/schemas.js

@@ -92,12 +92,4 @@ export const SearchSchema = z.object({
     time_range: z.enum(TIME_RANGES).default('all').optional(),
     limit: z.number().min(1).max(100).default(20).optional(),
 });
-/** moda loops — currently active loop detections. */
-export const LoopsSchema = z.object({
-    limit: z.number().min(1).max(200).default(25).optional(),
-});
-/** moda loop <detectionId> — single loop detection detail. */
-export const LoopDetailSchema = z.object({
-    detection_id: z.string().uuid({ message: 'detection_id must be a UUID' }),
-});
 //# sourceMappingURL=schemas.js.map

package/dist/tui.js

@@ -298,7 +298,6 @@ function overviewSignals(record) {
         ['Frustrations', valueAt(record, ['frustrations', 'total']) ?? record.frustrations],
         ['Runs', valueAt(record, ['runs', 'total']) ?? record.runs],
         ['Workflows', valueAt(record, ['workflows', 'total']) ?? record.workflows],
-        ['Loops', valueAt(record, ['loops', 'active']) ?? valueAt(record, ['loops', 'total']) ?? record.loops],
     ];
     return candidates
         .map(([label, value]) => [label, metricText(value)])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.13.10",
+  "version": "1.14.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-08T06:08:46.984Z",
-  "cli_version": "1.13.10",
+  "bundled_at": "2026-07-08T09:14:05.529Z",
+  "cli_version": "1.14.0",
   "skills": [
     {
       "id": "integration-node-anthropic",

package/skills/moda-cli/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: moda-cli
 version: 2.1.0
-description: Query Moda's AI agent conversation analytics and manage code-first prompt versions from the terminal — semantic/keyword/hybrid message search, overview KPIs, topic clusters, message context, user frustration detections, tool failures, active loop detections, and moda prompts status/sync/promote. Use when the user asks about moda, modaflows, conversation analytics, prompt management, user frustrations, agent observability, tool failure debugging, wants to find conversations or tool calls about a topic, or wants to investigate how their AI agent is performing.
+description: Query Moda's AI agent conversation analytics and manage code-first prompt versions from the terminal — semantic/keyword/hybrid message search, overview KPIs, topic clusters, message context, user frustration detections, tool failures, and moda prompts status/sync/promote. Use when the user asks about moda, modaflows, conversation analytics, prompt management, user frustrations, agent observability, tool failure debugging, wants to find conversations or tool calls about a topic, or wants to investigate how their AI agent is performing.
 ---
 
 # Moda CLI
@@ -475,7 +475,7 @@ Data API fallback. Abbreviated envelope:
 ```
 
 `moda investigate` also accepts scoping flags (`--tool`, `--run`,
-`--conversation`, `--loop`) to focus the ranking on one signal.
+`--conversation`) to focus the ranking on one signal.
 
 ### 3. Browse topic clusters
 
@@ -578,21 +578,7 @@ Pass `--include-window` to attach a `window` field per row with the message
 slice centered on the anchor. `--window=N` (1–5, default `1`) is the
 half-width; `--window=1` ⇒ 3 messages total (anchor ± 1).
 
-### 7. Active loop investigation
-
-```bash
-moda loops                                      # everything currently stuck
-moda loops --limit=10
-moda loop <detection_id>                        # one loop signature in detail
-```
-
-Loops are detected in real time by the conversation worker (tier 0/1) and
-the analytics container (tier 2). A row with `cycle_visits=378` means the
-agent re-ran the same action 378 times. Use the `loop_signature_human`
-field to recognize cross-conversation patterns (one tool definition bug
-will produce identical signatures across many users).
-
-### 8. Prompt management
+### 7. Prompt management
 
 Use these only when working on the code-first prompt registry.
 
@@ -762,8 +748,6 @@ npx: `npx -p @moda-ai/cli moda <command>`.
 | `moda frustrations` | User frustration detections with evidence |
 | `moda tool-failures` | Tool failure overview |
 | `moda tool-failure-detail <tool_name>` | Per-tool failure breakdown + examples |
-| `moda loops` | Currently-active loop detections |
-| `moda loop <detection_id>` | One loop signature with blast radius |
 | `moda prompts status` | Read-only local prompt status |
 | `moda prompts diff` | Read-only local prompt diff/status |
 | `moda prompts sync` | Upload changed prompt versions and update lockfile |