@moda-ai/cli 1.55.10 → 1.55.11

package/dist/production-intelligence-1tf98n79.js

@@ -0,0 +1,1802 @@
+import {
+  INTELLIGENCE_SCHEMA_VERSION,
+  asNumber,
+  asRecord,
+  asString,
+  frustrationAnchorIndex,
+  frustrationsFromEmotions,
+  shellWord
+} from "./cli-4qe6n8am.js";
+import {
+  renderMarkdownForTerminal,
+  shouldColorTerminalOutput,
+  stripAnsi,
+  terminalStyles
+} from "./cli-97fnztpy.js";
+import {
+  callControlAPI,
+  callDataAPI
+} from "./cli-tmqd1f0m.js";
+import {
+  apiKeyHeaders
+} from "./cli-m16taf4z.js";
+import {
+  CliAuthError,
+  CliInputError,
+  EXIT_DEGRADED,
+  EXIT_OK,
+  recordApiRequest,
+  resolveApiKey,
+  resolveModaBaseUrl,
+  safeWriteStderr
+} from "./cli-429zt7g4.js";
+import"./cli-0v6na3yp.js";
+
+// src/production-intelligence.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/ask-stream.ts
+class AskStreamError extends Error {
+  elapsedMs;
+  toolEvents;
+  accepted;
+  constructor(message) {
+    super(message);
+    this.name = "AskStreamError";
+  }
+}
+function canFallBackToBufferedAsk(error) {
+  return error instanceof AskStreamError && error.accepted !== true;
+}
+function askStreamInterruptedError(error) {
+  const secs = Math.round((error.elapsedMs ?? 0) / 1000);
+  return new Error(`The live ask stream dropped ${secs}s into a run the server had already accepted (${error.message}). ` + "Not re-running it, to avoid paying for a second agent run; the run may still complete server-side. " + 'Retry with `moda ask "<question>" --no-stream` in a minute (the buffered path has no live progress but survives drops).');
+}
+
+class SseParser {
+  buffer = "";
+  pendingCr = false;
+  push(chunk) {
+    let text = (this.pendingCr ? "\r" : "") + chunk;
+    this.pendingCr = false;
+    if (text.endsWith("\r")) {
+      this.pendingCr = true;
+      text = text.slice(0, -1);
+    }
+    this.buffer += text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+    const payloads = [];
+    let boundary = this.buffer.indexOf(`
+
+`);
+    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(`
+
+`);
+    }
+    return payloads;
+  }
+  flush() {
+    const remaining = this.buffer + (this.pendingCr ? "\r" : "");
+    this.buffer = "";
+    this.pendingCr = false;
+    const payload = dataPayloadOf(remaining.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`));
+    return payload !== null ? [payload] : [];
+  }
+}
+function dataPayloadOf(frame) {
+  const dataLines = [];
+  for (const line of frame.split(`
+`)) {
+    if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0)
+    return null;
+  const payload = dataLines.join(`
+`);
+  return payload.trim().length > 0 ? payload : null;
+}
+var RENDERED_PHASES = new Set(["planning", "searching", "analyzing", "writing"]);
+var IDLE_TICKER_THRESHOLD_MS = 1e4;
+var IDLE_TICKER_MIN_UPDATE_MS = 15000;
+var IDLE_TICKER_POLL_MS = 1000;
+
+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);
+    this.timer.unref?.();
+  }
+  touch() {
+    this.lastEventAt = this.now();
+  }
+  stop() {
+    if (this.timer !== undefined)
+      clearInterval(this.timer);
+    this.timer = undefined;
+  }
+  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 {}
+  }
+}
+
+class AskStreamCollector {
+  onProgress;
+  answer = "";
+  confidence = "medium";
+  citations = [];
+  nextCommands = [];
+  elapsedMs;
+  errorMessage;
+  terminal = false;
+  lastPhase;
+  toolNames = new Map;
+  toolEvents = 0;
+  events = 0;
+  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");
+    }
+    this.events += 1;
+    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": {
+        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 : "";
+        const name = stripAnsi(typeof tool?.tool === "string" ? tool.tool : "tool");
+        const title = stripAnsi(typeof tool?.title === "string" ? tool.title : name);
+        if (id)
+          this.toolNames.set(id, name);
+        this.onProgress(`• ${name} — ${title}…`);
+        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)}`);
+        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:
+        break;
+    }
+  }
+  isTerminal() {
+    return this.terminal;
+  }
+  get eventCount() {
+    return this.events;
+  }
+  get toolEventCount() {
+    return this.toolEvents;
+  }
+  finish() {
+    if (!this.terminal) {
+      throw new AskStreamError("stream ended before a terminal done/error event");
+    }
+    if (!this.errorMessage && this.answer.trim().length === 0) {
+      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 } : {}
+    };
+  }
+}
+var TOOL_CARD_DETAIL_MAX = 100;
+function oneLine(text) {
+  const collapsed = stripAnsi(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";
+}
+async function consumeAskSse(chunks, collector, 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();
+  }
+  return collector.finish();
+}
+function parsePayload(payload) {
+  try {
+    return JSON.parse(payload);
+  } catch {
+    throw new AskStreamError("stream emitted an unparseable frame");
+  }
+}
+var DEFAULT_STREAM_TIMEOUT_MS = 250000;
+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);
+  const startedAt = Date.now();
+  const onProgress = options.onProgress ?? (() => {});
+  const collector = new AskStreamCollector(onProgress);
+  const ticker = new IdleTicker(onProgress);
+  ticker.start();
+  let accepted = false;
+  try {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    let response;
+    try {
+      recordApiRequest();
+      response = await fetchImpl(url, {
+        method: "POST",
+        headers: {
+          ...apiKeyHeaders(resolveApiKey(profileOptions) ?? "", 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")) {
+      throw new AskStreamError(`stream endpoint returned unexpected content type '${contentType || "unknown"}'`);
+    }
+    accepted = true;
+    if (!response.body) {
+      throw new AskStreamError("stream response had no body");
+    }
+    try {
+      return await consumeAskSse(response.body, collector, () => ticker.touch());
+    } catch (error) {
+      if (error instanceof AskStreamError)
+        throw error;
+      throw new AskStreamError(`stream read failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  } catch (error) {
+    if (error instanceof AskStreamError) {
+      if (error.elapsedMs === undefined)
+        error.elapsedMs = Date.now() - startedAt;
+      if (error.toolEvents === undefined)
+        error.toolEvents = collector.toolEventCount;
+      if (error.accepted === undefined)
+        error.accepted = accepted || collector.eventCount > 0;
+    }
+    throw error;
+  } finally {
+    ticker.stop();
+    clearTimeout(timeout);
+  }
+}
+
+// src/production-intelligence.ts
+var INVESTIGATION_SCHEMA_VERSION = "production_investigation.v0.1";
+var OVERVIEW_SCHEMA_VERSION = "production_overview.v0.1";
+var ASK_SCHEMA_VERSION = "production_ask.v0.1";
+var INVESTIGATION_PROBLEM_LIMIT = 3;
+var INVESTIGATION_PROBLEM_SLOTS = INVESTIGATION_PROBLEM_LIMIT;
+async function runProductionCommand(context) {
+  const daysBack = daysBackFlag(context.flags);
+  if (context.command === "overview") {
+    const briefing = await loadOverviewBriefing({ daysBack, cwd: context.cwd });
+    if (context.flags.raw === "true") {
+      context.output.writeData(briefing.rawOverview, {
+        summary: "Loaded raw Moda overview.",
+        nextCommands: ["moda overview", `moda investigate --days-back=${daysBack}`]
+      });
+    } else if (context.outputMode === "human") {
+      if (!context.quiet)
+        console.log(renderOverviewBriefingHuman(briefing));
+    } else {
+      context.output.writeData(briefing, overviewAgentOptions(briefing));
+    }
+    return { exitCode: 0 };
+  }
+  if (context.command === "ask") {
+    const question = context.positionals.join(" ").trim();
+    if (!question) {
+      throw new CliInputError("<question> is required", 'Usage: moda ask "what should I fix first?" [--days-back=N] [--no-stream]');
+    }
+    const result = await askModaForContext(context, question, daysBack);
+    if (context.outputMode === "human") {
+      if (!context.quiet)
+        console.log(renderAskHuman(result));
+    } else {
+      context.output.writeData(result.intelligence, {
+        ...askAgentOptions(result),
+        status: result.degraded ? "degraded" : "success"
+      });
+    }
+    return { exitCode: result.degraded ? EXIT_DEGRADED : EXIT_OK };
+  }
+  if (context.command === "failures") {
+    const investigation = await investigateProduction({
+      daysBack,
+      cwd: context.cwd,
+      failureOnly: true,
+      toolName: context.flags.tool
+    });
+    writeInvestigation(context, investigation);
+    return { exitCode: 0 };
+  }
+  if (context.command === "investigate") {
+    const investigation = await investigateProduction({
+      daysBack,
+      cwd: context.cwd,
+      conversationId: context.flags.trace ?? context.flags.conversation,
+      toolName: context.flags.tool
+    });
+    writeInvestigation(context, investigation);
+    return { exitCode: 0 };
+  }
+  throw new CliInputError(`Unknown production command '${context.command}'`);
+}
+async function loadOverviewBriefing(options) {
+  const endpoint = `/overview?days_back=${options.daysBack}`;
+  const overview = await callDataAPI(endpoint);
+  const hints = loadHarnessHints(options.cwd);
+  const evidenceRefs = [
+    {
+      id: "overview:data",
+      kind: "data_api",
+      label: `Overview for last ${options.daysBack} day(s)`,
+      endpoint,
+      value: overviewMetrics(overview)
+    }
+  ];
+  const findings = findingsFromOverview(overview, options.daysBack, hints, evidenceRefs);
+  const topFinding = findings[0] ?? null;
+  const conversations = numberAt(overview, ["conversations", "total"]);
+  const recent = recentActivity(overview)[0];
+  const dataFlowStatus = conversations > 0 || recent ? "flowing" : "quiet";
+  const nextCommand = topFinding ? `moda investigate --days-back=${options.daysBack}` : "moda doctor --online";
+  return {
+    schemaVersion: OVERVIEW_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    daysBack: options.daysBack,
+    status: topFinding ? "attention" : dataFlowStatus === "flowing" ? "healthy" : "quiet",
+    dataFlow: {
+      status: dataFlowStatus,
+      conversations,
+      ...recent ? { lastEvent: recent } : {}
+    },
+    harnessSync: localSyncBrief(options.cwd, ".moda/sync-state.json", "Harness graph"),
+    promptSync: localSyncBrief(options.cwd, ".moda/prompts.lock.json", "Prompt versions"),
+    skillSync: localSkillBrief(options.cwd),
+    metrics: overviewMetrics(overview),
+    topFinding,
+    evidenceRefs,
+    nextCommand,
+    rawOverview: overview
+  };
+}
+async function investigateProduction(options) {
+  const warnings = [];
+  const sourceStatus = {};
+  const hints = loadHarnessHints(options.cwd);
+  const overviewEndpoint = `/overview?days_back=${options.daysBack}`;
+  const toolEndpoint = options.toolName ? `/tool-failures/${encodeURIComponent(options.toolName)}?days_back=${options.daysBack}&limit=5` : `/tool-failures?days_back=${options.daysBack}`;
+  const frustrationsEndpoint = `/emotions?family=frustration&days_back=${options.daysBack}&limit=5${options.conversationId ? `&conversation_id=${encodeURIComponent(options.conversationId)}` : ""}`;
+  const problemsEndpoint = `/problems?days_back=${options.daysBack}&limit=${INVESTIGATION_PROBLEM_LIMIT}`;
+  const skipped = { data: null, status: "ok" };
+  const [overview, tools, frustrations, problems] = await Promise.all([
+    safeData(overviewEndpoint),
+    safeData(toolEndpoint),
+    options.failureOnly ? Promise.resolve(skipped) : safeData(frustrationsEndpoint),
+    options.failureOnly ? Promise.resolve(skipped) : safeData(problemsEndpoint)
+  ]);
+  const sources = options.failureOnly ? { overview, tools } : { overview, tools, frustrations, problems };
+  for (const [key, result] of Object.entries(sources)) {
+    sourceStatus[key] = result.status;
+    if (result.warning)
+      warnings.push(result.warning);
+  }
+  if (options.toolName && tools.status === "ok" && toolRows(tools.data, options.toolName).every((row) => row.count <= 0)) {
+    warnings.push(`No failures found for tool "${options.toolName}" in the last ${options.daysBack} day(s) — the tool may have no failures in this window, or the name may not exist in this tenant. ` + "Run `moda tool-failures` to list tools with recorded failures, or widen --days-back.");
+  }
+  if (options.conversationId) {
+    warnings.push(`Scoped to trace ${options.conversationId} for frustration evidence only; overview and tool failures are tenant-wide. ` + `Open the trace itself with \`moda audit ${options.conversationId}\`.`);
+  }
+  const evidenceRefs = [];
+  const findings = [];
+  addOverviewEvidence(overview.data, overviewEndpoint, evidenceRefs);
+  findings.push(...toolFailureFindings(tools.data, options.daysBack, hints, evidenceRefs, options.toolName));
+  if (!options.failureOnly) {
+    findings.push(...frustrationFindings(frustrations.data, options.daysBack, evidenceRefs));
+    findings.push(...problemFindings(problems.data, options.daysBack, evidenceRefs));
+  }
+  if (findings.length === 0) {
+    findings.push(insufficientDataFinding(overview.data, evidenceRefs));
+  }
+  findings.sort(compareFindings);
+  const boundedFindings = capFindings(findings, 8, INVESTIGATION_PROBLEM_SLOTS);
+  const nextCommands = nextCommandsForFindings(boundedFindings, options.daysBack, !options.failureOnly);
+  const summary = summarizeInvestigation(boundedFindings);
+  if (options.conversationId) {
+    summary.text = `${summary.text} (Only frustration evidence is scoped to trace ${options.conversationId}.)`;
+  }
+  return {
+    schemaVersion: INVESTIGATION_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    daysBack: options.daysBack,
+    scope: {
+      ...options.conversationId ? { conversationId: options.conversationId } : {},
+      ...options.toolName ? { toolName: options.toolName } : {},
+      ...options.question ? { question: options.question } : {}
+    },
+    summary,
+    findings: boundedFindings,
+    evidenceRefs: uniqueEvidenceRefs(evidenceRefs),
+    nextCommands,
+    warnings,
+    sourceStatus
+  };
+}
+async function askModa(options) {
+  let fallbackReason = "Moda Cloud ask endpoint returned no answer.";
+  try {
+    const response = await callControlAPI("/cli/ask", {
+      method: "POST",
+      body: JSON.stringify({
+        question: options.question,
+        daysBack: options.daysBack,
+        profile: options.profile,
+        harness: localHarnessSummary(options.cwd)
+      })
+    }, options.profile ? { profile: options.profile } : {}, {
+      timeoutMs: askTimeoutMs(),
+      retries: 0,
+      retryOnceOnNetworkError: true,
+      onNetworkRetry: options.onNetworkRetry
+    });
+    const cloud = normalizeCloudAsk(response, options.question);
+    if (cloud)
+      return cloud;
+    fallbackReason = "Moda Cloud ask endpoint returned an empty answer.";
+  } catch (error) {
+    fallbackReason = `Moda Cloud ask endpoint unavailable: ${error instanceof Error ? error.message : String(error)}`;
+  }
+  const investigation = await investigateProduction({
+    daysBack: options.daysBack,
+    cwd: options.cwd,
+    question: options.question
+  });
+  const top = investigation.findings[0];
+  const answer = top ? `Moda Cloud intelligence is not available, so I synthesized this from production evidence. The strongest signal is: ${top.title}. ${top.summary}` : "Moda Cloud intelligence is not available, and the local Data API evidence did not contain a strong production signal.";
+  const confidence = capFallbackConfidence(investigation.summary.confidence);
+  const evidenceRefs = investigation.evidenceRefs.slice(0, 12);
+  const findings = investigation.findings.slice(0, 5);
+  const nextCommands = investigation.nextCommands;
+  const warnings = [
+    "Cloud ask endpoint unavailable; synthesized answer from local Data API evidence.",
+    fallbackReason,
+    ...investigation.warnings
+  ];
+  return {
+    schemaVersion: ASK_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    source: "local_fallback",
+    degraded: true,
+    fallbackReason,
+    question: options.question,
+    answer,
+    confidence,
+    evidenceRefs,
+    findings,
+    nextCommands,
+    warnings,
+    intelligence: synthesizeIntelligenceV1({
+      question: options.question,
+      answer,
+      confidence,
+      evidenceRefs,
+      nextCommands,
+      warnings,
+      source: "local_fallback",
+      degraded: true,
+      findings
+    })
+  };
+}
+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;
+}
+async function askModaForContext(context, question, daysBack) {
+  if (shouldStreamAsk(context)) {
+    const progressStyle = terminalStyles(shouldColorTerminalOutput({ isTTY: process.stderr.isTTY === true }));
+    const dimmed = (line) => line.startsWith("•") || line.startsWith("◦") || line.startsWith("…");
+    try {
+      const outcome = await streamAsk({
+        question,
+        daysBack,
+        profile: context.profile,
+        harness: localHarnessSummary(context.cwd),
+        timeoutMs: askTimeoutMs(),
+        onProgress: (line) => safeWriteStderr(`${dimmed(line) ? progressStyle.dim(line) : line}
+`)
+      });
+      return askResultFromStreamOutcome(outcome, question);
+    } catch (error) {
+      if (error instanceof CliAuthError)
+        throw error;
+      if (error instanceof AskStreamError && !canFallBackToBufferedAsk(error)) {
+        throw askStreamInterruptedError(error);
+      }
+      if (context.verbose) {
+        safeWriteStderr(`[moda] live progress unavailable (${error instanceof Error ? error.message : String(error)}); using buffered ask.
+`);
+      }
+    }
+  }
+  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…
+`) : undefined
+  });
+}
+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,
+    href: citation.href
+  }));
+  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
+    })
+  };
+}
+function askTimeoutMs() {
+  const raw = Number(process.env.MODA_ASK_TIMEOUT_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : 250000;
+}
+function writeInvestigation(context, investigation) {
+  if (context.outputMode === "human") {
+    if (!context.quiet)
+      console.log(renderInvestigationHuman(investigation));
+    return;
+  }
+  context.output.writeData(investigation, investigationAgentOptions(investigation));
+}
+async function safeData(endpoint) {
+  try {
+    return { data: await callDataAPI(endpoint), status: "ok" };
+  } catch (error) {
+    return {
+      data: null,
+      status: "unavailable",
+      warning: `Could not load ${endpoint}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+function findingsFromOverview(overview, daysBack, hints, evidenceRefs) {
+  const findings = [];
+  const toolFailureTotal = numberAt(overview, ["tool_failures", "total"]);
+  if (toolFailureTotal > 0) {
+    const conversations = numberAt(overview, ["tool_failures", "conversations"]);
+    const evidenceId = "overview:tool_failures";
+    evidenceRefs.push({
+      id: evidenceId,
+      kind: "data_api",
+      label: `${toolFailureTotal} tool failure(s) across ${conversations} trace(s)`,
+      endpoint: `/overview?days_back=${daysBack}`,
+      value: valueAt(overview, ["tool_failures"])
+    });
+    findings.push({
+      id: "finding_overview_tool_failures",
+      kind: "tool_failure",
+      title: `${toolFailureTotal} tool failure(s) need investigation`,
+      severity: severityForCount(toolFailureTotal, 10, 3),
+      confidence: "medium",
+      impactScore: 80 + Math.min(toolFailureTotal, 20),
+      rankReason: "Tool failures directly block agent tasks and have explicit production evidence.",
+      summary: `Moda saw ${toolFailureTotal} failed tool call(s) in the last ${daysBack} day(s).`,
+      evidenceRefIds: [evidenceId],
+      likelyLocations: defaultLikelyLocations(hints, "tool"),
+      recommendedActions: [{
+        id: "action_investigate_tools",
+        title: "Open the ranked production investigation.",
+        rationale: "The overview only has aggregate counts; investigation pulls examples and likely file paths.",
+        command: `moda investigate --days-back=${daysBack}`,
+        mutability: "read",
+        requiresApproval: false
+      }]
+    });
+  }
+  const frustrationRate = numberAt(overview, ["frustrations", "rate_pct"]);
+  const frustrated = numberAt(overview, ["frustrations", "frustrated"]);
+  if (frustrated > 0 || frustrationRate >= 10) {
+    const evidenceId = "overview:frustrations";
+    evidenceRefs.push({
+      id: evidenceId,
+      kind: "data_api",
+      label: `${frustrationRate}% frustration rate`,
+      endpoint: `/overview?days_back=${daysBack}`,
+      value: valueAt(overview, ["frustrations"])
+    });
+    findings.push({
+      id: "finding_overview_frustration",
+      kind: "frustration",
+      title: `${frustrationRate}% user frustration rate`,
+      severity: frustrationRate >= 25 ? "high" : "medium",
+      confidence: "medium",
+      impactScore: 65 + Math.min(frustrationRate, 30),
+      rankReason: "Frustration indicates users are getting stuck even when runs may not hard-fail.",
+      summary: `Moda classified ${frustrated} frustrated trace(s) in the last ${daysBack} day(s).`,
+      evidenceRefIds: [evidenceId],
+      likelyLocations: defaultLikelyLocations(hints, "prompt"),
+      recommendedActions: [{
+        id: "action_investigate_frustration",
+        title: "Inspect frustration anchors.",
+        rationale: "Frustration anchors show the user turn where the experience degraded.",
+        command: `moda frustrations --days-back=${daysBack} --include-window`,
+        mutability: "read",
+        requiresApproval: false
+      }]
+    });
+  }
+  return findings.sort(compareFindings);
+}
+function toolFailureFindings(data, daysBack, hints, evidenceRefs, scopedTool) {
+  const tools = toolRows(data, scopedTool);
+  return tools.flatMap((tool) => {
+    const name = tool.name;
+    if (!name)
+      return [];
+    const count = tool.count;
+    if (count <= 0)
+      return [];
+    const evidenceId = `tool:${name}`;
+    const subtype = tool.subtype ? ` (${tool.subtype})` : "";
+    evidenceRefs.push({
+      id: evidenceId,
+      kind: "tool_failure",
+      label: `${name}: ${count} failure(s)${subtype}`,
+      endpoint: scopedTool ? `/tool-failures/${encodeURIComponent(name)}?days_back=${daysBack}` : `/tool-failures?days_back=${daysBack}`,
+      toolName: name,
+      value: tool.raw
+    });
+    const location = likelyToolLocation(name, hints);
+    if (location?.path) {
+      evidenceRefs.push({
+        id: `harness:tool:${name}`,
+        kind: "harness",
+        label: `Likely tool definition for ${name}`,
+        path: location.path,
+        toolName: name
+      });
+    }
+    const conversations = tool.conversations > 0 ? tool.conversations : count;
+    return [{
+      id: `finding_tool_failure_${slug(name)}`,
+      kind: "tool_failure",
+      title: `${name} is failing in production`,
+      severity: severityForCount(count, 10, 3),
+      confidence: "high",
+      impactScore: 90 + Math.min(count, 25),
+      rankReason: `${count} failed call(s) across ${conversations} trace(s), with direct tool failure evidence.`,
+      summary: `${name} produced ${count} failed call(s) in the last ${daysBack} day(s).${tool.subtype ? ` The dominant subtype is ${tool.subtype}.` : ""}`,
+      evidenceRefIds: location?.path ? [evidenceId, `harness:tool:${name}`] : [evidenceId],
+      likelyLocations: [location ?? unknownLocation("tool", `No local definition matched ${name}.`)],
+      recommendedActions: [{
+        id: `action_tool_detail_${slug(name)}`,
+        title: `Inspect ${name} failure examples.`,
+        rationale: "Examples include trace anchors and error subtypes.",
+        command: `moda tool-failure-detail ${name} --days-back=${daysBack} --include-window`,
+        mutability: "read",
+        requiresApproval: false
+      }]
+    }];
+  });
+}
+function frustrationFindings(data, daysBack, evidenceRefs) {
+  data = frustrationsFromEmotions(asRecord(data) ?? {});
+  const summary = asRecord(valueAt(data, ["summary"]));
+  const frustrations = Array.isArray(valueAt(data, ["frustrations"])) ? valueAt(data, ["frustrations"]) : [];
+  const count = numberValue(summary?.frustrated_count) || frustrations.length;
+  const atRisk = numberValue(summary?.at_risk_count);
+  if (count <= 0 && atRisk <= 0 && frustrations.length === 0)
+    return [];
+  const first = asRecord(frustrations[0]);
+  const conversationId = asString(first?.conversation_id);
+  const quote = firstQuote(first);
+  const anchorIndex = frustrationAnchorIndex(first);
+  const evidenceId = conversationId ? `frustration:${conversationId}` : "frustration:summary";
+  evidenceRefs.push({
+    id: evidenceId,
+    kind: "frustration",
+    label: quote ? `Frustration anchor: "${quote}"` : `${count} frustrated trace(s)`,
+    endpoint: `/emotions?family=frustration&days_back=${daysBack}&limit=5`,
+    ...conversationId ? { conversationId } : {},
+    value: first ?? summary ?? data
+  });
+  return [{
+    id: "finding_frustration_rate",
+    kind: "frustration",
+    title: count > 0 ? `${count} frustrated trace(s)` : `${atRisk} at-risk trace(s)`,
+    severity: count >= 10 ? "high" : "medium",
+    confidence: first ? "high" : "medium",
+    impactScore: 70 + Math.min(count * 3 + atRisk, 25),
+    rankReason: "User frustration is a product-quality signal even when the agent technically completes.",
+    summary: first?.primary_cause ? `Primary cause: ${String(first.primary_cause)}.` : `Moda found frustration or risk in the last ${daysBack} day(s).`,
+    evidenceRefIds: [evidenceId],
+    likelyLocations: [unknownLocation("prompt", "Prompt or policy issue likely; inspect the trace window.")],
+    recommendedActions: [{
+      id: "action_frustration_window",
+      title: "Read the frustration window.",
+      rationale: "The user quote and nearby turns reveal what confused or blocked the user.",
+      command: conversationId ? `moda context ${shellWord(conversationId)}${anchorIndex !== null ? ` --msg-index=${anchorIndex}` : ""} --window=3` : `moda frustrations --days-back=${daysBack} --include-window`,
+      mutability: "read",
+      requiresApproval: false
+    }]
+  }];
+}
+function problemRows(data) {
+  const record = asRecord(data);
+  const rows = [];
+  const push = (items, trust) => {
+    if (!Array.isArray(items))
+      return;
+    for (const item of items) {
+      const row = asRecord(item);
+      const id = asString(row?.problem_id);
+      if (!row || !id)
+        continue;
+      const lifecycle = asString(row.lifecycle) ?? "open";
+      if (lifecycle === "resolved")
+        continue;
+      rows.push({
+        id,
+        name: asString(row.display_name) || id,
+        cause: asString(row.cause_statement) || asString(row.display_description) || undefined,
+        lifecycle,
+        trust,
+        verification: asString(row.verification_status) ?? undefined,
+        affectedConversations: numberValue(row.affected_conversations) || numberValue(asRecord(row.evidence_support)?.attribution_count),
+        raw: row
+      });
+    }
+  };
+  push(record?.problems, "trusted");
+  push(record?.untrusted, "untrusted");
+  push(record?.emerging, "emerging");
+  return rows.slice(0, INVESTIGATION_PROBLEM_LIMIT);
+}
+function problemFindings(data, daysBack, evidenceRefs) {
+  return problemRows(data).map((problem, index) => {
+    const evidenceId = `problem:${problem.id}`;
+    const trusted = problem.trust === "trusted";
+    const trustNote = trusted ? "verified" : problem.trust === "emerging" ? "emerging, not yet ranked" : `untrusted (${problem.verification ?? "unverified"})`;
+    evidenceRefs.push({
+      id: evidenceId,
+      kind: "problem",
+      label: `Problem "${problem.name}" (${trustNote})`,
+      endpoint: `/problems?days_back=${daysBack}&limit=${INVESTIGATION_PROBLEM_LIMIT}`,
+      value: problem.raw
+    });
+    const affected = problem.affectedConversations;
+    return {
+      id: `finding_problem_${slug(problem.id)}`,
+      kind: "problem",
+      title: `Problem: ${problem.name}`,
+      severity: trusted ? affected >= 10 ? "critical" : "high" : "medium",
+      confidence: trusted ? "high" : "low",
+      impactScore: (trusted ? 100 : 60) + Math.min(affected, 25) - index,
+      rankReason: trusted ? `Rank #${index + 1} verified Problem in \`moda problems\`${affected > 0 ? `, affecting ${affected} trace(s)` : ""}.` : `Listed by \`moda problems\` as ${trustNote}; treat the cause as a hypothesis.`,
+      summary: problem.cause ? `${problem.cause}${problem.lifecycle !== "open" ? ` (${problem.lifecycle})` : ""}` : `Problem ${problem.id} is ${problem.lifecycle} in the last ${daysBack} day(s).`,
+      evidenceRefIds: [evidenceId],
+      likelyLocations: [],
+      recommendedActions: [{
+        id: `action_problem_${slug(problem.id)}`,
+        title: `Open the Problem dossier for ${problem.name}.`,
+        rationale: "The dossier has the cause, evidence, affected traces and verification state.",
+        command: `moda problem ${problem.id}`,
+        mutability: "read",
+        requiresApproval: false
+      }]
+    };
+  });
+}
+function insufficientDataFinding(overview, evidenceRefs) {
+  const evidenceId = "overview:data";
+  if (!evidenceRefs.some((ref) => ref.id === evidenceId)) {
+    evidenceRefs.push({
+      id: evidenceId,
+      kind: "data_api",
+      label: "Overview did not contain actionable production signals",
+      endpoint: "/overview",
+      value: overview
+    });
+  }
+  return {
+    id: "finding_insufficient_data",
+    kind: "insufficient_data",
+    title: "No strong production issue found yet",
+    severity: "info",
+    confidence: "medium",
+    impactScore: 10,
+    rankReason: "Moda needs more recent production traces before ranking failures.",
+    summary: "Data flow may be quiet or current signals are below the investigation threshold.",
+    evidenceRefIds: [evidenceId],
+    likelyLocations: [],
+    recommendedActions: [{
+      id: "action_doctor_online",
+      title: "Validate data flow.",
+      rationale: "A quiet overview can mean no traffic or broken ingestion.",
+      command: "moda doctor --online",
+      mutability: "read",
+      requiresApproval: false
+    }]
+  };
+}
+function normalizeCloudAsk(response, question) {
+  const record = asRecord(response);
+  const answer = asString(record?.answer);
+  if (!answer)
+    return null;
+  const evidenceRefs = Array.isArray(record?.evidence_refs) ? record.evidence_refs.flatMap((item) => {
+    const ref = asRecord(item);
+    if (!ref)
+      return [];
+    return [{
+      id: asString(ref.id) ?? `ask:evidence:${slug(asString(ref.label) ?? "ref")}`,
+      kind: evidenceKind(asString(ref.kind)),
+      label: asString(ref.label) ?? asString(ref.id) ?? "Cloud evidence",
+      path: asString(ref.path) ?? undefined,
+      value: ref.value,
+      href: asString(ref.href) ?? undefined
+    }];
+  }) : [];
+  const nextCommands = Array.isArray(record?.next_commands) ? record.next_commands.filter((item) => typeof item === "string") : ["moda investigate"];
+  const confidence = normalizeConfidence(record?.confidence);
+  const intelligenceRecord = asRecord(record?.intelligence);
+  const intelligence = looksLikeIntelligenceV1(intelligenceRecord) ? coerceIntelligenceV1(intelligenceRecord, { question, answer, confidence }) : synthesizeIntelligenceV1({
+    question,
+    answer,
+    confidence,
+    evidenceRefs,
+    nextCommands,
+    warnings: [],
+    source: "cloud",
+    degraded: false
+  });
+  return {
+    schemaVersion: ASK_SCHEMA_VERSION,
+    generatedAt: new Date().toISOString(),
+    source: "cloud",
+    degraded: false,
+    question,
+    answer,
+    confidence,
+    evidenceRefs,
+    findings: [],
+    nextCommands,
+    warnings: [],
+    intelligence
+  };
+}
+function looksLikeIntelligenceV1(record) {
+  if (!record)
+    return false;
+  const version = asString(record.schema_version);
+  if (version && version !== INTELLIGENCE_SCHEMA_VERSION)
+    return false;
+  return version === INTELLIGENCE_SCHEMA_VERSION || typeof record.answer_markdown === "string" || asRecord(record.summary) !== null;
+}
+function coerceIntelligenceV1(record, context) {
+  const summaryRecord = asRecord(record.summary);
+  const summary = {
+    text: asString(summaryRecord?.text) ?? context.answer,
+    confidence: confidenceValue(summaryRecord?.confidence) ?? context.confidence
+  };
+  const evidenceRefs = Array.isArray(record.evidence_refs) ? record.evidence_refs.flatMap(coerceV1EvidenceRef) : [];
+  const answerClaims = Array.isArray(record.answer_claims) ? record.answer_claims.flatMap(coerceV1Claim) : [];
+  const findings = Array.isArray(record.findings) ? record.findings.flatMap(coerceV1Finding) : [];
+  const nextCommands = Array.isArray(record.next_commands) ? record.next_commands.flatMap(coerceV1NextCommand) : [];
+  const warnings = stringArray(record.warnings);
+  const meta = asRecord(record.meta);
+  return {
+    schema_version: INTELLIGENCE_SCHEMA_VERSION,
+    generated_at: asString(record.generated_at) ?? new Date().toISOString(),
+    command: asString(record.command) ?? "ask",
+    source: record.source === "local_fallback" ? "local_fallback" : "cloud",
+    degraded: record.degraded === true,
+    question: asString(record.question) ?? context.question,
+    summary,
+    answer_markdown: asString(record.answer_markdown) ?? context.answer,
+    answer_claims: answerClaims,
+    findings,
+    evidence_refs: evidenceRefs,
+    next_commands: nextCommands,
+    warnings,
+    ...meta ? { meta } : {}
+  };
+}
+function synthesizeIntelligenceV1(options) {
+  return {
+    schema_version: INTELLIGENCE_SCHEMA_VERSION,
+    generated_at: new Date().toISOString(),
+    command: "ask",
+    source: options.source,
+    degraded: options.degraded,
+    question: options.question,
+    summary: { text: options.answer, confidence: options.confidence },
+    answer_markdown: options.answer,
+    answer_claims: [],
+    findings: (options.findings ?? []).map(productionFindingToV1),
+    evidence_refs: options.evidenceRefs.map(productionEvidenceToV1),
+    next_commands: options.nextCommands.map(commandStringToV1),
+    warnings: options.warnings
+  };
+}
+function coerceV1EvidenceRef(item) {
+  const ref = asRecord(item);
+  if (!ref)
+    return [];
+  const label = asString(ref.label);
+  const anchor = coerceV1Anchor(asRecord(ref.anchor));
+  const snippet = asString(ref.snippet);
+  return [{
+    id: asString(ref.id) ?? `ask:evidence:${slug(label ?? "ref")}`,
+    kind: asString(ref.kind) ?? "ask",
+    label: label ?? asString(ref.id) ?? "Cloud evidence",
+    ...anchor ? { anchor } : {},
+    ...snippet ? { snippet } : {},
+    grounding: provenanceValue(ref.grounding) ?? "measured"
+  }];
+}
+function coerceV1Anchor(record) {
+  if (!record)
+    return;
+  const anchor = {
+    ...asString(record.conversation_id) ? { conversation_id: asString(record.conversation_id) } : {},
+    ...asNumber(record.message_index) !== null ? { message_index: asNumber(record.message_index) } : {},
+    ...asString(record.run_id) ? { run_id: asString(record.run_id) } : {},
+    ...asString(record.tool_name) ? { tool_name: asString(record.tool_name) } : {}
+  };
+  return Object.keys(anchor).length > 0 ? anchor : undefined;
+}
+function coerceV1Claim(item) {
+  const claim = asRecord(item);
+  if (!claim)
+    return [];
+  const text = asString(claim.text);
+  if (!text)
+    return [];
+  const value = asNumber(claim.value);
+  const matchedPath = asString(claim.matched_path);
+  return [{
+    text,
+    ...value !== null ? { value } : {},
+    kind: claim.kind === "percentage" || claim.kind === "count" ? claim.kind : "qualitative",
+    status: claim.status === "grounded" || claim.status === "ungrounded" ? claim.status : "unverifiable",
+    evidence_ref_ids: stringArray(claim.evidence_ref_ids),
+    ...matchedPath ? { matched_path: matchedPath } : {}
+  }];
+}
+function coerceV1Finding(item) {
+  const finding = asRecord(item);
+  if (!finding)
+    return [];
+  const id = asString(finding.id);
+  const title = asString(finding.title);
+  if (!id || !title)
+    return [];
+  const severity = finding.severity;
+  const description = asString(finding.description);
+  return [{
+    id,
+    title,
+    ...severity === "critical" || severity === "high" || severity === "medium" || severity === "low" || severity === "info" ? { severity } : {},
+    ...description ? { description } : {},
+    evidence_ref_ids: stringArray(finding.evidence_ref_ids),
+    recommended_actions: Array.isArray(finding.recommended_actions) ? finding.recommended_actions.flatMap(coerceV1RecommendedAction) : []
+  }];
+}
+function coerceV1RecommendedAction(item) {
+  const action = asRecord(item);
+  if (!action)
+    return [];
+  const id = asString(action.id);
+  const title = asString(action.title);
+  if (!id || !title)
+    return [];
+  const rationale = asString(action.rationale);
+  const command = asString(action.command);
+  return [{
+    id,
+    title,
+    ...rationale ? { rationale } : {},
+    ...command ? { command } : {},
+    mutability: mutabilityValue(action.mutability) ?? "unknown",
+    requires_approval: action.requires_approval === true
+  }];
+}
+function coerceV1NextCommand(item) {
+  if (typeof item === "string")
+    return [commandStringToV1(item)];
+  const record = asRecord(item);
+  if (!record)
+    return [];
+  const command = asString(record.command);
+  if (!command)
+    return [];
+  const purpose = asString(record.purpose);
+  return [{
+    command,
+    ...purpose ? { purpose } : {},
+    mutability: mutabilityValue(record.mutability) ?? mutabilityForCommand(command),
+    requires_approval: typeof record.requires_approval === "boolean" ? record.requires_approval : requiresApprovalForCommand(command)
+  }];
+}
+function productionEvidenceToV1(ref) {
+  const anchor = {
+    ...ref.conversationId ? { conversation_id: ref.conversationId } : {},
+    ...ref.runId ? { run_id: ref.runId } : {},
+    ...ref.toolName ? { tool_name: ref.toolName } : {}
+  };
+  return {
+    id: ref.id,
+    kind: ref.kind,
+    label: ref.label,
+    ...Object.keys(anchor).length > 0 ? { anchor } : {},
+    grounding: "measured"
+  };
+}
+function productionFindingToV1(finding) {
+  return {
+    id: finding.id,
+    title: finding.title,
+    severity: finding.severity,
+    description: `${finding.summary} ${finding.rankReason}`.trim(),
+    evidence_ref_ids: finding.evidenceRefIds,
+    recommended_actions: finding.recommendedActions.map((action) => ({
+      id: action.id,
+      title: action.title,
+      rationale: action.rationale,
+      command: action.command,
+      mutability: action.mutability,
+      requires_approval: action.requiresApproval
+    }))
+  };
+}
+function commandStringToV1(command) {
+  return {
+    command,
+    purpose: purposeForCommand(command),
+    mutability: mutabilityForCommand(command),
+    requires_approval: requiresApprovalForCommand(command)
+  };
+}
+function mutabilityForCommand(command) {
+  return command.includes(" sync") ? "sync" : "read";
+}
+function requiresApprovalForCommand(command) {
+  return command.includes(" sync") || command.includes(" --yes");
+}
+function stringArray(value) {
+  return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+}
+function confidenceValue(value) {
+  return value === "high" || value === "medium" || value === "low" || value === "unknown" ? value : null;
+}
+function provenanceValue(value) {
+  return value === "measured" || value === "inferred" ? value : null;
+}
+function mutabilityValue(value) {
+  return value === "read" || value === "write" || value === "sync" || value === "unknown" ? value : null;
+}
+function investigationAgentOptions(investigation) {
+  return {
+    summary: investigation.summary,
+    findings: investigation.findings.map(agentFinding),
+    evidenceRefs: investigation.evidenceRefs.map(agentEvidence),
+    recommendedActions: investigation.findings.flatMap((finding) => finding.recommendedActions.map(agentAction)),
+    nextCommands: investigation.nextCommands.map(nextCommand),
+    warnings: investigation.warnings
+  };
+}
+function overviewAgentOptions(briefing) {
+  return {
+    summary: {
+      text: `Moda health briefing: ${briefing.status}. Next: ${briefing.nextCommand}`,
+      confidence: briefing.topFinding ? briefing.topFinding.confidence : "medium"
+    },
+    findings: briefing.topFinding ? [agentFinding(briefing.topFinding)] : [],
+    evidenceRefs: briefing.evidenceRefs.map(agentEvidence),
+    recommendedActions: briefing.topFinding ? briefing.topFinding.recommendedActions.map(agentAction) : [],
+    nextCommands: [nextCommand(briefing.nextCommand)]
+  };
+}
+function askAgentOptions(result) {
+  const errors = result.degraded ? [{
+    code: "cloud_unavailable",
+    message: result.fallbackReason ?? "Moda Cloud intelligence was unavailable; answer synthesized from local Data API evidence.",
+    blocking: false,
+    suggested_commands: ["moda doctor --online"]
+  }] : [];
+  return {
+    summary: { text: result.answer, confidence: result.confidence },
+    findings: result.findings.map(agentFinding),
+    evidenceRefs: result.evidenceRefs.map(agentEvidence),
+    recommendedActions: result.findings.flatMap((finding) => finding.recommendedActions.map(agentAction)),
+    nextCommands: result.nextCommands.map(nextCommand),
+    warnings: result.warnings,
+    errors
+  };
+}
+function agentFinding(finding) {
+  return {
+    id: finding.id,
+    title: finding.title,
+    severity: finding.severity,
+    description: `${finding.summary} ${finding.rankReason}`,
+    evidence_ref_ids: finding.evidenceRefIds
+  };
+}
+function agentEvidence(ref) {
+  return {
+    id: ref.id,
+    kind: ref.kind,
+    label: ref.label,
+    path: ref.path,
+    line: ref.line,
+    href: ref.href
+  };
+}
+function agentAction(action) {
+  return {
+    id: action.id,
+    title: action.title,
+    rationale: action.rationale,
+    command: action.command,
+    mutability: action.mutability,
+    requires_approval: action.requiresApproval
+  };
+}
+function nextCommand(command) {
+  return {
+    command,
+    purpose: purposeForCommand(command),
+    mutability: command.includes(" sync") ? "sync" : "read",
+    requires_approval: command.includes(" sync") || command.includes(" --yes")
+  };
+}
+function renderOverviewBriefingHuman(briefing) {
+  const lines = [];
+  lines.push("Moda overview");
+  lines.push("Production health briefing");
+  lines.push("");
+  lines.push(`Status      ${briefing.status}`);
+  lines.push(`Data flow   ${briefing.dataFlow.status} (${briefing.dataFlow.conversations} trace(s))`);
+  if (briefing.dataFlow.lastEvent) {
+    lines.push(`Last event  ${briefing.dataFlow.lastEvent.summary}${briefing.dataFlow.lastEvent.timestamp ? ` - ${briefing.dataFlow.lastEvent.timestamp}` : ""}`);
+  }
+  lines.push("");
+  lines.push("Sync");
+  lines.push(`  Harness   ${briefing.harnessSync.status} - ${briefing.harnessSync.summary}`);
+  lines.push(`  Prompts   ${briefing.promptSync.status} - ${briefing.promptSync.summary}`);
+  lines.push(`  Skills    ${briefing.skillSync.status} - ${briefing.skillSync.summary}`);
+  lines.push("");
+  lines.push("Signals");
+  for (const [label, value] of overviewSignalPairs(briefing.metrics)) {
+    lines.push(`  ${label.padEnd(18)} ${String(value)}`);
+  }
+  lines.push("");
+  lines.push("Top signal");
+  if (briefing.topFinding) {
+    lines.push(`  ${briefing.topFinding.severity.toUpperCase()} ${briefing.topFinding.title}`);
+    lines.push(`  ${briefing.topFinding.summary}`);
+    lines.push(`  Why ranked: ${briefing.topFinding.rankReason}`);
+  } else {
+    lines.push("  No urgent production issue found in the selected window.");
+  }
+  lines.push("");
+  lines.push("Next best action");
+  lines.push(`  ${briefing.nextCommand}`);
+  return lines.join(`
+`);
+}
+function renderInvestigationHuman(investigation) {
+  const lines = [];
+  lines.push("Moda investigation");
+  lines.push(`Window: last ${investigation.daysBack} day(s)`);
+  lines.push("");
+  lines.push(investigation.summary.text);
+  for (const finding of investigation.findings) {
+    lines.push("");
+    lines.push(`${finding.severity.toUpperCase()} ${finding.title}`);
+    lines.push(`  Confidence: ${finding.confidence}`);
+    lines.push(`  Impact: ${finding.impactScore}`);
+    lines.push(`  ${finding.summary}`);
+    lines.push(`  Why ranked: ${finding.rankReason}`);
+    if (finding.likelyLocations.length > 0) {
+      lines.push("  Likely location:");
+      for (const location of finding.likelyLocations.slice(0, 3)) {
+        lines.push(`    - ${location.path ?? location.label} (${location.confidence})`);
+      }
+    }
+    if (finding.recommendedActions.length > 0) {
+      lines.push("  Next:");
+      for (const action of finding.recommendedActions.slice(0, 2)) {
+        lines.push(`    ${action.command}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push("Next commands");
+  for (const command of investigation.nextCommands.slice(0, 6))
+    lines.push(`  ${command}`);
+  if (investigation.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings");
+    for (const warning of investigation.warnings.slice(0, 5))
+      lines.push(`  - ${warning}`);
+  }
+  return lines.join(`
+`);
+}
+function renderAskHuman(result, options = {}) {
+  const color = options.color ?? shouldColorTerminalOutput();
+  const style = terminalStyles(color);
+  const lines = [];
+  lines.push(style.heading("Moda ask"));
+  lines.push(`${style.dim("Question:")} ${result.question}`);
+  if (result.degraded) {
+    lines.push("");
+    lines.push("[degraded] Moda Cloud was unavailable — this answer is synthesized from local Data API evidence (lower trust).");
+  }
+  lines.push("");
+  lines.push(renderMarkdownForTerminal(result.answer, { color }));
+  lines.push("");
+  lines.push(`Confidence: ${style.bold(result.confidence)}`);
+  lines.push(`Source: ${result.source}${result.degraded ? " (degraded)" : ""}`);
+  if (result.evidenceRefs.length > 0) {
+    lines.push("");
+    lines.push(style.bold("Evidence"));
+    const grounding = new Map(result.intelligence.evidence_refs.map((ref) => [ref.id, ref.grounding]));
+    const dashboardBase = resolveModaBaseUrl();
+    for (const ref of result.evidenceRefs.slice(0, 8)) {
+      const marker = grounding.get(ref.id) === "inferred" ? " (inferred)" : "";
+      const label = stripAnsi(ref.label);
+      const path = ref.path ? ` (${stripAnsi(ref.path)})` : "";
+      const link = ref.href ? `
+    ${style.dim(`${dashboardBase}${stripAnsi(ref.href)}`)}` : "";
+      lines.push(`  - ${label}${path}${marker}${link}`);
+    }
+  }
+  const unverifiedClaims = result.intelligence.answer_claims.filter((claim) => claim.status !== "grounded").length;
+  if (unverifiedClaims > 0) {
+    lines.push("");
+    lines.push(`Note: ${unverifiedClaims} claim(s) could not be grounded against tool data.`);
+  }
+  if (result.nextCommands.length > 0) {
+    lines.push("");
+    lines.push(style.bold("Next commands"));
+    for (const command of result.nextCommands.slice(0, 5))
+      lines.push(`  ${stripAnsi(command)}`);
+  }
+  if (result.warnings.length > 0) {
+    lines.push("");
+    lines.push(style.bold("Warnings"));
+    for (const warning of result.warnings.slice(0, 3))
+      lines.push(`  - ${stripAnsi(warning)}`);
+  }
+  return lines.join(`
+`);
+}
+function addOverviewEvidence(data, endpoint, refs) {
+  refs.push({
+    id: "overview:data",
+    kind: "data_api",
+    label: "Production overview aggregate",
+    endpoint,
+    value: overviewMetrics(data)
+  });
+}
+function toolRows(data, scopedTool) {
+  const record = asRecord(data);
+  const directToolName = asString(record?.tool_name) ?? scopedTool;
+  const examples = Array.isArray(record?.examples) ? record.examples : [];
+  if (directToolName) {
+    const subtypes = (Array.isArray(record?.subtypes) ? record.subtypes : []).map((item) => asRecord(item)).filter((item) => item !== null && item !== undefined);
+    const subtypeTotal = subtypes.reduce((sum, item) => sum + numberValue(item.count), 0);
+    const top = [...subtypes].sort((left, right) => numberValue(right.count) - numberValue(left.count))[0];
+    return [{
+      name: directToolName,
+      count: numberValue(record?.failure_count) || numberValue(record?.total_failures) || numberValue(asRecord(record?.pagination)?.total) || subtypeTotal || examples.length,
+      conversations: numberValue(record?.failed_conversations) || numberValue(record?.conversation_count) || Math.max(0, ...subtypes.map((item) => numberValue(item.conversation_count))) || examples.length,
+      subtype: asString(record?.top_error_subtype) ?? asString(record?.error_subtype) ?? asString(top?.subtype) ?? undefined,
+      raw: data
+    }];
+  }
+  const tools = Array.isArray(record?.tools) ? record.tools : Array.isArray(record?.tool_failures) ? record.tool_failures : Array.isArray(record?.failures) ? record.failures : [];
+  return tools.flatMap((item) => {
+    const row = asRecord(item);
+    const name = asString(row?.tool_name) ?? asString(row?.name);
+    if (!name)
+      return [];
+    return [{
+      name,
+      count: numberValue(row?.failure_count) || numberValue(row?.total_failures) || numberValue(row?.count),
+      conversations: numberValue(row?.failed_conversations) || numberValue(row?.conversation_count),
+      subtype: asString(row?.top_error_subtype) ?? asString(row?.error_subtype) ?? undefined,
+      raw: row
+    }];
+  });
+}
+function firstQuote(row) {
+  const quotes = Array.isArray(row?.user_quotes) ? row.user_quotes : [];
+  const first = asRecord(quotes[0]);
+  return asString(first?.quote) ?? undefined;
+}
+function likelyToolLocation(toolName, hints) {
+  const normalized = normalizeKey(toolName);
+  for (const [key, path] of hints.toolPaths.entries()) {
+    if (key.includes(normalized) || normalized.includes(key)) {
+      return {
+        kind: "tool",
+        path,
+        label: `Tool definition for ${toolName}`,
+        confidence: "medium",
+        reason: "Matched tool name against the local harness graph."
+      };
+    }
+  }
+  return null;
+}
+function defaultLikelyLocations(hints, kind) {
+  const source = kind === "tool" ? hints.toolPaths : kind === "prompt" ? hints.promptPaths : hints.skillPaths;
+  const first = [...source.values()][0];
+  if (first) {
+    return [{
+      kind,
+      path: first,
+      label: `${kind} artifact`,
+      confidence: "low",
+      reason: "The overview is aggregate-only; investigation will map specific production evidence."
+    }];
+  }
+  if (hints.reportPath) {
+    return [{
+      kind: "harness",
+      path: hints.reportPath,
+      label: "Local harness manifest",
+      confidence: "low",
+      reason: "Use the local harness graph to map production signals to code."
+    }];
+  }
+  return [];
+}
+function unknownLocation(kind, reason) {
+  return {
+    kind,
+    label: "Unknown local path",
+    confidence: "unknown",
+    reason
+  };
+}
+function loadHarnessHints(cwd) {
+  const hints = {
+    toolPaths: new Map,
+    promptPaths: new Map,
+    skillPaths: new Map,
+    entrypointPaths: []
+  };
+  const harnessPath = join(cwd, ".moda", "harness.json");
+  if (!existsSync(harnessPath))
+    return hints;
+  hints.reportPath = ".moda/harness.json";
+  try {
+    const parsed = JSON.parse(readFileSync(harnessPath, "utf8"));
+    const graph = asRecord(parsed);
+    const artifacts = Array.isArray(graph?.artifacts) ? graph.artifacts : [];
+    for (const item of artifacts) {
+      const artifact = asRecord(item);
+      if (!artifact)
+        continue;
+      const name = asString(artifact.name) ?? asString(artifact.id) ?? "";
+      const path = asString(artifact.sourcePath) ?? asString(artifact.path);
+      const type = asString(artifact.type);
+      if (!path || !name)
+        continue;
+      const key = normalizeKey(name);
+      if (type === "tool")
+        hints.toolPaths.set(key, path);
+      if (type === "prompt")
+        hints.promptPaths.set(key, path);
+      if (type === "skill")
+        hints.skillPaths.set(key, path);
+      if (type === "entrypoint")
+        hints.entrypointPaths.push(path);
+    }
+  } catch {
+    return hints;
+  }
+  return hints;
+}
+function localHarnessSummary(cwd) {
+  const path = join(cwd, ".moda", "harness.json");
+  if (!existsSync(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return {
+      harnessId: parsed.harnessId,
+      graphHash: parsed.graphHash,
+      runtimeAgentCount: Array.isArray(parsed.runtimeAgents) ? parsed.runtimeAgents.length : undefined
+    };
+  } catch {
+    return null;
+  }
+}
+function localSyncBrief(cwd, relativePath, label) {
+  const path = join(cwd, relativePath);
+  if (!existsSync(path)) {
+    return { status: "missing", summary: `${label} state not found`, path: relativePath };
+  }
+  return { status: "present", summary: `${label} state exists locally`, path: relativePath };
+}
+function localSkillBrief(cwd) {
+  const claudeSkill = join(cwd, ".claude", "skills");
+  const cursorRules = join(cwd, ".cursor", "rules");
+  if (existsSync(claudeSkill) || existsSync(cursorRules)) {
+    return { status: "present", summary: "Local agent skill/rule directory exists" };
+  }
+  return { status: "missing", summary: "No local agent skill/rule directory found" };
+}
+function summarizeInvestigation(findings) {
+  const top = findings[0];
+  if (!top) {
+    return { text: "No production findings were generated.", confidence: "unknown" };
+  }
+  if (top.kind === "insufficient_data") {
+    return { text: top.title, confidence: top.confidence };
+  }
+  return {
+    text: `Top production finding: ${top.title}. ${top.summary}`,
+    confidence: top.confidence
+  };
+}
+function nextCommandsForFindings(findings, daysBack, includeProblems = false) {
+  const limit = 8;
+  const primary = [...new Set(findings.map((finding) => finding.recommendedActions[0]?.command).filter(Boolean))];
+  const generic = [
+    ...includeProblems ? [`moda problems --days-back=${daysBack}`] : [],
+    `moda overview --days-back=${daysBack}`,
+    "moda doctor --online"
+  ];
+  const secondary = findings.flatMap((finding) => finding.recommendedActions.slice(1).map((action) => action.command)).filter(Boolean);
+  const keep = new Set(primary);
+  for (const command of [...generic, ...secondary]) {
+    if (keep.size >= Math.max(limit, primary.length))
+      break;
+    keep.add(command);
+  }
+  const ordered = [
+    ...findings.flatMap((finding) => finding.recommendedActions.map((action) => action.command)).filter(Boolean),
+    ...generic
+  ];
+  return [...new Set(ordered)].filter((command) => keep.has(command));
+}
+function capFindings(sorted, limit, problemSlots) {
+  const reserved = [
+    ...sorted.filter((finding) => finding.kind === "problem").slice(0, problemSlots),
+    ...sorted.filter((finding) => finding.kind === "frustration").slice(0, 1)
+  ];
+  const others = sorted.filter((finding) => !reserved.includes(finding)).slice(0, limit - reserved.length);
+  const kept = new Set([...reserved, ...others]);
+  return sorted.filter((finding) => kept.has(finding));
+}
+function compareFindings(a, b) {
+  const severityDelta = severityWeight(b.severity) - severityWeight(a.severity);
+  if (severityDelta !== 0)
+    return severityDelta;
+  return b.impactScore - a.impactScore;
+}
+function severityWeight(severity) {
+  return { critical: 5, high: 4, medium: 3, low: 2, info: 1 }[severity];
+}
+function severityForCount(count, high, medium) {
+  if (count >= high)
+    return "critical";
+  if (count >= medium)
+    return "high";
+  return "medium";
+}
+function uniqueEvidenceRefs(refs) {
+  const seen = new Set;
+  const out = [];
+  for (const ref of refs) {
+    if (seen.has(ref.id))
+      continue;
+    seen.add(ref.id);
+    out.push(ref);
+  }
+  return out;
+}
+function overviewMetrics(data) {
+  return {
+    conversations: valueAt(data, ["conversations", "total"]) ?? 0,
+    conversationTrendPct: valueAt(data, ["conversations", "trend_pct"]) ?? 0,
+    toolFailures: valueAt(data, ["tool_failures", "total"]) ?? 0,
+    failedToolConversations: valueAt(data, ["tool_failures", "conversations"]) ?? 0,
+    impactedTools: valueAt(data, ["tool_failures", "tools"]) ?? 0,
+    frustrated: valueAt(data, ["frustrations", "frustrated"]) ?? 0,
+    atRisk: valueAt(data, ["frustrations", "at_risk"]) ?? 0,
+    frustrationRatePct: valueAt(data, ["frustrations", "rate_pct"]) ?? 0,
+    recentActivity: recentActivity(data).length
+  };
+}
+function overviewSignalPairs(metrics) {
+  return [
+    ["Traces", metrics.conversations],
+    ["Tool failures", metrics.toolFailures],
+    ["Failed traces", metrics.failedToolConversations],
+    ["Impacted tools", metrics.impactedTools],
+    ["Frustrated", metrics.frustrated],
+    ["At risk", metrics.atRisk],
+    ["Frustration %", metrics.frustrationRatePct],
+    ["Recent events", metrics.recentActivity]
+  ];
+}
+function recentActivity(data) {
+  const activity = valueAt(data, ["recent_activity"]);
+  if (!Array.isArray(activity))
+    return [];
+  return activity.flatMap((item) => {
+    const row = asRecord(item);
+    const summary = asString(row?.summary) ?? asString(row?.title) ?? asString(row?.event);
+    if (!summary)
+      return [];
+    return [{
+      summary,
+      timestamp: asString(row?.timestamp) ?? asString(row?.created_at) ?? undefined,
+      conversationId: asString(row?.conversation_id) ?? undefined
+    }];
+  });
+}
+function valueAt(value, path) {
+  let cursor = value;
+  for (const key of path) {
+    const record = asRecord(cursor);
+    if (!record)
+      return;
+    cursor = record[key];
+  }
+  return cursor;
+}
+function numberAt(value, path) {
+  return numberValue(valueAt(value, path));
+}
+function numberValue(value) {
+  const direct = asNumber(value);
+  if (direct !== null)
+    return direct;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+function daysBackFlag(flags, fallback = 7) {
+  const raw = flags["days-back"];
+  if (raw === undefined)
+    return fallback;
+  const parsed = Number(raw);
+  if (raw.trim() === "" || raw === "true" || !Number.isInteger(parsed) || parsed < 1 || parsed > 90) {
+    throw new CliInputError(`--days-back must be a whole number from 1 to 90; got '${raw}'.`, "Nothing was run. Example: --days-back=7 (the default).");
+  }
+  return parsed;
+}
+function normalizeConfidence(value) {
+  if (value === "high" || value === "medium" || value === "low" || value === "unknown")
+    return value;
+  return "medium";
+}
+function capFallbackConfidence(confidence) {
+  return confidence === "high" ? "medium" : confidence;
+}
+function evidenceKind(value) {
+  if (value === "data_api" || value === "tool_failure" || value === "frustration" || value === "problem" || value === "harness" || value === "ask")
+    return value;
+  return "ask";
+}
+function normalizeKey(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "");
+}
+function slug(value) {
+  const clean = value.replace(/[^a-zA-Z0-9_-]+/g, "_").replace(/^_+|_+$/g, "");
+  return clean || "unknown";
+}
+function purposeForCommand(command) {
+  if (command.startsWith("moda investigate"))
+    return "Open the ranked production investigation.";
+  if (command.startsWith("moda tool-failure-detail"))
+    return "Inspect tool failure examples and trace anchors.";
+  if (command.startsWith("moda problems"))
+    return "List the ranked Problems.";
+  if (command.startsWith("moda problem "))
+    return "Open the Problem dossier.";
+  if (command.startsWith("moda context"))
+    return "Read the relevant trace window.";
+  if (command.startsWith("moda doctor"))
+    return "Validate Moda setup and data flow.";
+  if (command.startsWith("moda overview"))
+    return "Return to the harness health briefing.";
+  return "Suggested next Moda command.";
+}
+export {
+  shouldStreamAsk,
+  runProductionCommand,
+  renderAskHuman,
+  loadOverviewBriefing,
+  investigateProduction,
+  daysBackFlag,
+  askResultFromStreamOutcome,
+  askModa
+};