@moda-ai/cli 1.25.0 → 1.26.0

package/README.md

@@ -34,49 +34,87 @@ Get your API key from [moda.dev/settings](https://moda.dev/settings).
 
 ## Usage
 
+Find things by meaning, then drill in:
+
 ```bash
-moda overview                                    # Dashboard overview
-moda overview --days-back=30                     # Last 30 days
+moda search "user wants a refund" --mode=semantic  # Semantic/keyword/hybrid message search
+moda search "stripe.charges.create" --mode=keyword # Exact identifiers, incl. tool calls
+moda search "checkout" --include-tool-io           # Search tool inputs/outputs too
+moda context <conversation_id> --msg-index=5       # Read the exact turn
+moda audit <conversation_id|trace_id>              # Raw span/trace audit
+```
 
-moda clusters                                    # Browse topic clusters
-moda clusters --parent-id=node-abc               # Drill into a category
+Production intelligence:
 
-moda cluster-conversations <node_id>             # Conversations in a cluster
+```bash
+moda overview --days-back=30                     # Health briefing (KPIs, clusters, activity)
+moda ask "what should I fix first?"              # Grounded answer with evidence
+moda investigate                                 # Ranked issues worth fixing
+moda problems                                    # Cross-signal Problems by root cause
+moda problem <problem_id>                        # One Problem: full dossier
+moda problem <problem_id> --evidence             #   ...attribution evidence (keyset paged)
+moda problem <problem_id> --reports              #   ...investigation reports
+moda problem <problem_id> --conversations        #   ...affected conversations
+moda problem-feedback <problem_id> --action=mark_fixed   # Close the loop from the terminal
+```
 
-moda conversations --search="error"              # Search conversations
-moda conversations --time-range=24h              # Filter by time
-moda conversations --environment=production      # Filter by environment
+Signals:
 
-moda context <conversation_id>                   # Get conversation context
-moda context <conversation_id> --msg-index=5     # Center on message 5
+```bash
+moda emotions --family=confusion                 # Multi-family emotion detections
+moda hallucinations --kind=contradicted          # Grounding: contradicted/verified outputs
+moda frustrations --include-window --window=1    # Legacy single-family frustration view
+moda tool-failures                               # Tool failure overview
+moda tool-failure-detail <tool_name> --include-window
+moda step-scores <conversation_id>               # Graph-PRM per-step reward curves
+```
 
-moda frustrations                                # User frustration detections
-moda frustrations --days-back=14 --limit=20
-moda frustrations --include-window --window=1    # Attach 3-message slice per row
+Conversations, clusters, memory:
 
-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
+```bash
+moda conversations --search="error" --environment=production
+moda clusters                                    # Walk the topic hierarchy
+moda clusters --search="billing disputes"        # Find a cluster by meaning
+moda world-state <conversation_id>               # Agent memory (slots/threads/events)
+moda world-state <id> --snapshot --msg-index=42  # What the agent believed at turn 42
+moda world-state <id> --replay --message-count=50  # State evolution frame by frame
+```
 
-moda feedback "cluster label looks wrong"        # Help us improve: flag wrong/missing data
-moda feedback "..." --category=missing_data --conversation-id=<id>
+Live tail (one JSON line per new item — `tail -f` for your agent):
 
-# Prompt management
+```bash
+moda tail                                        # New conversations, every 15s
+moda tail --signal=all --interval=30             # Conversations + emotion detections
+```
+
+Prompt management:
+
+```bash
 moda prompts init                                # Create .moda/prompts.yml
 moda prompts status                              # Read-only local prompt status
-moda prompts diff                                # Read-only local prompt diff/status
 moda prompts sync                                # Upload changed prompt versions
-moda prompts sync --watch                        # Sync when local prompt hashes change
 moda prompts promote support.triage --label=prod --version=pver_abc123
 ```
 
-All commands output JSON. Pipe to `jq` for filtering:
+Feedback:
 
 ```bash
-moda overview | jq '.frustrations'
-moda frustrations | jq '.frustrations[].primary_cause'
+moda feedback "cluster label looks wrong" --category=bad_cluster_label
 ```
 
+Output adapts to where it runs: piped/CI/agent environments get schema-versioned
+JSON (`moda.agent.v1`), an interactive terminal gets human prose. Force a mode
+with `--json`, `--agent`, or `--human`. In JSON modes, pipe to `jq`:
+
+```bash
+moda overview | jq '.data.metrics'
+moda frustrations | jq '.data.frustrations[].primary_cause'
+```
+
+Every command supports `moda <command> --help` for scoped usage, and
+`moda manifest --json` describes the full machine protocol (commands, exit
+codes, event schema) for agents.
+
 ## Prompt Management
 
 Prompt management is code-first. Keep prompts in `prompts/**/*.prompt.md` or

package/dist/{cli-vc7zddj1.js → cli-59yacef3.js}

@@ -1301,6 +1301,19 @@ function createAgentEvent(command, event, state) {
   };
   return redactDeep(stamped);
 }
+function formatValidationMessage(error) {
+  const issues = error.issues;
+  if (error.name !== "ZodError" || !Array.isArray(issues) || issues.length === 0) {
+    return error.message;
+  }
+  const parts = issues.map((issue) => {
+    const record = issue;
+    const path = Array.isArray(record.path) && record.path.length > 0 ? record.path.join(".") : "input";
+    const message = typeof record.message === "string" ? record.message : "is invalid";
+    return `${path}: ${message}`;
+  });
+  return `Validation error — ${parts.join("; ")}`;
+}
 function errorToAgentError(error) {
   if (error instanceof CliInputRequiredError) {
     return {
@@ -1344,7 +1357,7 @@ function errorToAgentError(error) {
     if (error instanceof CliInputError || error.name === "ZodError") {
       return {
         code: "input_error",
-        message: error.message,
+        message: formatValidationMessage(error),
         cause: "usage" in error && typeof error.usage === "string" ? error.usage : undefined,
         suggested_commands: "usage" in error && typeof error.usage === "string" ? extractSuggestedCommands(error.usage) : undefined,
         blocking: true

package/dist/{cli-8s69sg7f.js → cli-9xw5bq1j.js}

@@ -8,7 +8,7 @@ import {
   saveProfileConfig,
   secretFilePathFromRef,
   writeSecretJsonFile
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/auth-storage.ts
 import { existsSync, readFileSync, rmSync } from "node:fs";

package/dist/{cli-jntzpem2.js → cli-g931ntph.js}

@@ -23,7 +23,7 @@ import {
   resolveTenantId,
   shouldInventoryFile,
   stringOption
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/api-client.ts
 var REQUEST_TIMEOUT_MS = 30000;
@@ -3338,7 +3338,7 @@ async function runHarnessCommand(context) {
         elapsed_ms: Date.now() - context.startedAt
       });
       if (context.flags["github-actions"] === "true") {
-        const { runGithubActionsAnalyze } = await import("./harness-github-actions-rjyc9a7z.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-ct8fwzdr.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);

package/dist/{cli-tdttb4cv.js → cli-pq6rte0w.js}

@@ -1,7 +1,7 @@
 import {
   authFetch,
   getCachedLoginContext
-} from "./cli-8s69sg7f.js";
+} from "./cli-9xw5bq1j.js";
 import {
   CliAccessError,
   CliInputError,
@@ -15,7 +15,7 @@ import {
   resolveTenantIdFromActiveProfile,
   saveCliConfig,
   writeSecretJsonFile
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/init/tenant.ts
 import { randomUUID } from "node:crypto";

package/dist/{cli-kqvjt12y.js → cli-xf5nx5hc.js}

@@ -11,11 +11,11 @@ import {
   renderStatusHuman,
   scanHarness,
   validateHarnessReport
-} from "./cli-jntzpem2.js";
+} from "./cli-g931ntph.js";
 import {
   isAuthSessionValid,
   loadAuthSession
-} from "./cli-8s69sg7f.js";
+} from "./cli-9xw5bq1j.js";
 import {
   CliInputError,
   createCommandContext,
@@ -31,7 +31,7 @@ import {
   resolveTenantId,
   secretFilePathFromRef,
   validateConfig
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/prompts.ts
 import { execFileSync } from "node:child_process";

package/dist/cli.js

@@ -5,7 +5,7 @@ import {
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-kqvjt12y.js";
+} from "./cli-xf5nx5hc.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -26,7 +26,7 @@ import {
   summarizeHarness,
   terminalStyles,
   validateHarnessReport
-} from "./cli-jntzpem2.js";
+} from "./cli-g931ntph.js";
 import {
   authFetch,
   clearAuthSession,
@@ -34,7 +34,7 @@ import {
   loadAuthSession,
   login,
   revokeCliSessionToken
-} from "./cli-8s69sg7f.js";
+} from "./cli-9xw5bq1j.js";
 import {
   AGENT_ERROR_CODES,
   CliAccessError,
@@ -79,7 +79,7 @@ import {
   validateConfig,
   wasOutputCancelled,
   writeSecretJsonFile
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/cli.ts
 import { z as z2 } from "zod";
@@ -92,7 +92,11 @@ var OverviewSchema = z.object({
 });
 var ClustersSchema = z.object({
   parent_id: z.string().optional(),
-  time_range: z.enum(["all", "1h", "3d", "7d", "24h", "30d", "90d"]).default("all").optional()
+  time_range: z.enum(["all", "1h", "3d", "7d", "24h", "30d", "90d"]).default("all").optional(),
+  search: z.string().min(2).max(200).optional(),
+  node_id: z.string().min(1).max(512).optional(),
+  mode: z.enum(["fuzzy", "semantic", "hybrid"]).optional(),
+  limit: z.number().min(1).max(50).optional()
 });
 var ClusterConversationsSchema = z.object({
   node_id: z.string(),
@@ -114,7 +118,14 @@ var ConversationsSchema = z.object({
 var WorldStateSchema = z.object({
   conversation_id: z.string(),
   summary_only: boolFlag(),
-  event_limit: z.number().min(1).max(5000).default(2000).optional()
+  event_limit: z.number().min(1).max(5000).default(2000).optional(),
+  snapshot: boolFlag(),
+  msg_index: z.number().min(0).max(1e5).optional(),
+  block_index: z.number().min(0).max(1e5).optional(),
+  segment_index: z.number().min(0).max(65535).optional(),
+  replay: boolFlag(),
+  format: z.enum(["frames", "fold-inputs"]).optional(),
+  message_count: z.number().min(1).max(1e6).optional()
 });
 var ContextSchema = z.object({
   conversation_id: z.string(),
@@ -135,6 +146,73 @@ var ProblemsSchema = z.object({
   days_back: z.number().min(1).max(90).default(30).optional(),
   limit: z.number().min(1).max(25).default(25).optional()
 });
+var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var PROBLEM_FAMILIES = [
+  "tool_failure",
+  "emotion",
+  "laziness",
+  "hallucination",
+  "prm_dip"
+];
+var PROBLEM_DOORS = ["rubric_match", "local_causal_chain"];
+var ProblemSchema = z.object({
+  id: z.string().min(1),
+  evidence: boolFlag(),
+  reports: boolFlag(),
+  conversations: boolFlag(),
+  feedback: boolFlag(),
+  limit: z.number().min(1).max(50).optional(),
+  cursor: z.string().optional(),
+  family: z.enum(PROBLEM_FAMILIES).optional(),
+  door: z.enum(PROBLEM_DOORS).optional()
+});
+var PROBLEM_FEEDBACK_ACTIONS = [
+  "mark_fixed",
+  "dismiss",
+  "flag_attribution",
+  "rename"
+];
+var ProblemFeedbackSchema = z.object({
+  id: z.string().min(1),
+  action: z.enum(PROBLEM_FEEDBACK_ACTIONS),
+  reason: z.string().max(2000).optional(),
+  attribution_id: z.string().max(64).optional(),
+  new_name: z.string().max(255).optional(),
+  actor: z.string().max(255).optional()
+});
+var EMOTION_FAMILIES = [
+  "frustration",
+  "sadness",
+  "confusion",
+  "anxiety",
+  "trust",
+  "positive"
+];
+var EmotionsSchema = z.object({
+  days_back: z.number().min(1).max(90).default(7).optional(),
+  limit: z.number().min(1).max(20).default(10).optional(),
+  offset: z.number().min(0).max(1e4).optional(),
+  family: z.enum(EMOTION_FAMILIES).optional()
+});
+var HallucinationsSchema = z.object({
+  days_back: z.number().min(1).max(90).default(7).optional(),
+  limit: z.number().min(1).max(20).default(10).optional(),
+  offset: z.number().min(0).max(1e4).optional(),
+  conversation_id: z.string().max(200).optional(),
+  kind: z.enum(["contradicted", "verified"]).optional()
+});
+var StepScoresSchema = z.object({
+  conversation_id: z.string().min(1)
+});
+var TAIL_SIGNALS = ["conversations", "emotions", "all"];
+var TailSchema = z.object({
+  interval: z.number().min(5).max(3600).default(15).optional(),
+  signal: z.enum(TAIL_SIGNALS).default("conversations").optional(),
+  once: boolFlag(),
+  limit: z.number().min(1).max(50).default(20).optional(),
+  max_events: z.number().min(1).max(1e5).optional(),
+  full_scan: boolFlag()
+});
 var ToolFailureDetailSchema = z.object({
   tool_name: z.string(),
   subtype: z.string().optional(),
@@ -158,7 +236,7 @@ var SearchSchema = z.object({
   user_id: z.string().optional(),
   time_range: z.enum(TIME_RANGES).default("all").optional(),
   limit: z.number().min(1).max(100).default(20).optional(),
-  include_tool_io: z.boolean().default(false).optional()
+  include_tool_io: boolFlag()
 });
 var FEEDBACK_CATEGORIES = [
   "bad_cluster_label",
@@ -1173,6 +1251,10 @@ var ONLINE_PROBE_TIMEOUT_MS = 5000;
 function subcommand(context) {
   return context.positionals[0];
 }
+function unknownSubcommandError(parent, attempted, valid) {
+  const message = attempted ? `Unknown ${parent} subcommand '${attempted}'. Valid subcommands: ${valid.join(", ")}.` : `A ${parent} subcommand is required. Valid subcommands: ${valid.join(", ")}.`;
+  return new CliInputError(message, `Usage: moda ${parent} <${valid.join("|")}>`);
+}
 function requirePositional(context, index, usage) {
   const value = context.positionals[index];
   if (!value)
@@ -1318,7 +1400,7 @@ async function runAuthCommand(context) {
       return { exitCode: EXIT_OK };
     }
     default:
-      throw new CliInputError("Unknown auth command.", "Usage: moda auth <login|logout|status|token|whoami>");
+      throw unknownSubcommandError("auth", subcommand(context), ["login", "logout", "status", "token", "whoami"]);
   }
 }
 async function runProfilesCommand(context) {
@@ -1396,12 +1478,12 @@ async function runProfilesCommand(context) {
       return { exitCode: 0 };
     }
     default:
-      throw new CliInputError("Unknown profiles command.", "Usage: moda profiles <list|use|create|doctor>");
+      throw unknownSubcommandError("profiles", subcommand(context), ["list", "use", "create", "doctor"]);
   }
 }
 async function runConfigCommand(context) {
   if (subcommand(context) !== "show") {
-    throw new CliInputError("Unknown config command.", "Usage: moda config show");
+    throw unknownSubcommandError("config", subcommand(context), ["show"]);
   }
   const config = loadProfileConfig({ env: context.env });
   const profile = getActiveProfile({ profile: context.profile, env: context.env });
@@ -1460,7 +1542,7 @@ async function runKeysCommand(context) {
       throw new CliInputError(`moda keys ${action} is waiting on Moda Cloud key lifecycle support for ${keyId}.`, `Required endpoint: ${KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS[action]}`);
     }
     default:
-      throw new CliInputError("Unknown keys command.", "Usage: moda keys <list|create|rotate|revoke>");
+      throw unknownSubcommandError("keys", subcommand(context), ["list", "create", "rotate", "revoke"]);
   }
 }
 
@@ -3855,10 +3937,16 @@ Commands:
   world-state <conversation_id>    Get a conversation's world state (slots/threads/events)
   context <conversation_id>        Get windowed conversation context
   audit <conversation_id|trace_id> Raw span/trace audit (spans, hierarchy, orphans, duplicates)
-  frustrations                     Get user frustration detections
+  frustrations                     Get user frustration detections (legacy single-family; see emotions)
+  emotions                         Multi-family emotion detections (frustration, sadness, confusion, anxiety, trust, positive)
+  hallucinations                   Grounding detections: contradicted/verified outputs with rule breakdown
   tool-failures                    Get tool failure overview
   tool-failure-detail <tool_name>  Get per-tool failure detail
   problems                         Rank cross-signal Problems by root cause (what to fix first)
+  problem <problem_id>             Open one Problem: dossier, or --evidence/--reports/--conversations/--feedback
+  problem-feedback <problem_id>    Mark a Problem fixed, dismiss, rename, or flag a bad attribution
+  step-scores <conversation_id>    Graph-PRM step scores (per-segment curves, first bad step, rollup)
+  tail                             Live-tail new conversations/detections as NDJSON (one line per item)
   feedback "<note>"                Flag wrong/missing data or CLI quirks to the Moda team
 
   Prompt management:
@@ -3924,6 +4012,52 @@ Search flags:
 World-state flags:
   --summary-only                   Return segment summaries only (omit the event stream)
   --event-limit=N                  Max world-state events to return (1-5000, default 2000)
+  --snapshot                       Folded slots at an exact tick (what the agent believed at that turn)
+  --msg-index=N --block-index=M    Snapshot tick (defaults 0; --segment-index=K scopes to a segment)
+  --replay                         State-over-time replay; frames mode REQUIRES --message-count=N
+  --format=frames|fold-inputs      Replay format (default frames)
+  --message-count=N                Number of frames to fold (frames mode)
+
+Emotions flags:
+  --family=F                       frustration|sadness|confusion|anxiety|trust|positive
+  --days-back=N --limit=N          Window 1-90 (default 7); page size 1-20 (default 10)
+  --offset=N                       Skip N detections (0-10000)
+
+Hallucinations flags:
+  --kind=contradicted|verified     Narrow the detections list
+  --conversation-id=ID             Scope summary + list to one conversation
+  --days-back=N --limit=N          Window 1-90 (default 7); page size 1-20 (default 10)
+
+Problem flags (moda problem <id>):
+  --evidence|--reports|--conversations|--feedback
+                                   Open one sub-resource page (at most one)
+  --limit=N --cursor=TOKEN         Keyset paging (1-50; pass next_cursor back verbatim)
+  --family=F --door=D              Filter --conversations (families: tool_failure|emotion|laziness|hallucination|prm_dip)
+
+Problem-feedback flags:
+  --action=A                       mark_fixed|dismiss|flag_attribution|rename (required)
+  --reason=TEXT                    Required for dismiss and flag_attribution
+  --attribution-id=UUID            Required for flag_attribution (ids come from problem --evidence)
+  --new-name=NAME                  Required for rename
+
+Tail flags:
+  --signal=S                       conversations|emotions|all (default conversations)
+  --interval=N                     Poll every N seconds (5-3600, default 15)
+  --once                           One poll, then exit (baseline page)
+  --limit=N --max-events=N         Page size per poll; stop after N stdout records
+                                   (metadata included; a slot is reserved for the
+                                   emotions coverage record, which falls back to
+                                   stderr if the bound leaves no room)
+  --full-scan                      Emotions: scan the whole window instead of the
+                                   top-scoring prefix (many more requests). /emotions
+                                   is score-ranked with no cursor, so the default
+                                   follows the highest-scoring detections and emits a
+                                   tail_coverage line stating exactly what it saw.
+
+Clusters search flags:
+  --search="query"                 Find clusters by name/meaning (task-cluster search)
+  --node-id=ID                     Deterministically resolve one cluster node (deep link)
+  --mode=fuzzy|semantic|hybrid     Cluster search mode (default hybrid)
 
 Feedback flags:
   --category=CAT                   bad_cluster_label|mismatched_frustration|missing_data|noisy_data|
@@ -4009,6 +4143,16 @@ Examples:
   moda search "billing error" --mode=hybrid
   moda search "refund flow" --mode=semantic --time-range=7d --limit=10
   moda world-state <conversation_id> --summary-only
+  moda world-state <conversation_id> --snapshot --msg-index=42
+  moda world-state <conversation_id> --replay --message-count=50
+  moda clusters --search="billing disputes"
+  moda emotions --family=confusion --days-back=14
+  moda hallucinations --kind=contradicted
+  moda problems --days-back=7
+  moda problem <problem_id> --evidence --limit=10
+  moda problem-feedback <problem_id> --action=mark_fixed
+  moda step-scores <conversation_id>
+  moda tail --signal=all --interval=30
   moda frustrations --days-back=14 --limit=20
   moda feedback "cluster label looks wrong" --category=bad_cluster_label --cluster-id=<node_id>
   moda context <conversation_id> --window=3
@@ -4020,6 +4164,25 @@ Examples:
   moda prompts ab --baseline=prompts/agent.prompt.md --candidate=prompts/agent-v2.prompt.md --conversations=conv_1,conv_2
   moda skills pull`);
 }
+function printCommandHelp(definition) {
+  const lines = [];
+  lines.push(`moda ${definition.name} — ${definition.description}`);
+  if (definition.aliases && definition.aliases.length > 0) {
+    lines.push(`Aliases: ${definition.aliases.join(", ")}`);
+  }
+  if (definition.mutability === "write") {
+    lines.push("This command can mutate state.");
+  }
+  if (definition.examples.length > 0) {
+    lines.push("", "Examples:");
+    for (const example of definition.examples) {
+      lines.push(`  ${example}`);
+    }
+  }
+  lines.push("", "Run 'moda --help' for the full command list and common flags", "(--json, --agent, --profile, --days-back, --limit, --time-range, ...).");
+  console.error(lines.join(`
+`));
+}
 async function attachWindows(rows, windowSize) {
   return Promise.all(rows.map(async (row) => {
     const anchor = asRecord(row.anchor);
@@ -4051,14 +4214,201 @@ async function attachWindows(rows, windowSize) {
     }
   }));
 }
-async function printWithOptionalWindows(enriched, listKey, includeWindow, windowSize, output) {
+async function printWithOptionalWindows(enriched, listKey, includeWindow, windowSize, output, warnings) {
+  const writeOptions = warnings && warnings.length > 0 ? { warnings } : undefined;
   if (!includeWindow) {
-    output.writeData(enriched);
+    output.writeData(enriched, writeOptions);
     return;
   }
   const list = Array.isArray(enriched[listKey]) ? enriched[listKey] : [];
   const withWindows = await attachWindows(list, windowSize);
-  output.writeData({ ...enriched, [listKey]: withWindows });
+  output.writeData({ ...enriched, [listKey]: withWindows }, writeOptions);
+}
+function notFoundWarning(entity, id, isMissing) {
+  if (!isMissing)
+    return [];
+  return [
+    `No ${entity} found for id "${id}" — it may not exist in this tenant (the Data API returns an empty result rather than an error for unknown ids).`
+  ];
+}
+var TAIL_SEEN_MAX = 5000;
+var EMOTIONS_TAIL_PAGE_SIZE = 20;
+var EMOTIONS_TAIL_MAX_PAGES = 25;
+var EMOTIONS_OFFSET_CEILING = 1e4;
+var EMOTIONS_FULL_SCAN_MAX_PAGES = Math.floor(EMOTIONS_OFFSET_CEILING / EMOTIONS_TAIL_PAGE_SIZE) + 1;
+var EMOTIONS_SEEN_MAX = EMOTIONS_FULL_SCAN_MAX_PAGES * EMOTIONS_TAIL_PAGE_SIZE + 2000;
+var CONVERSATIONS_SEEN_MAX = TAIL_SEEN_MAX;
+var TAIL_LIMITS = {
+  emotionsPageSize: EMOTIONS_TAIL_PAGE_SIZE,
+  emotionsFullScanMaxPages: EMOTIONS_FULL_SCAN_MAX_PAGES,
+  emotionsSeenMax: EMOTIONS_SEEN_MAX,
+  conversationsSeenMax: CONVERSATIONS_SEEN_MAX,
+  independentKeyspaces: true
+};
+async function runTailCommand(params, context) {
+  const intervalMs = (params.interval ?? 15) * 1000;
+  const signal = params.signal ?? "conversations";
+  const limit = params.limit ?? 20;
+  const seenConversations = new Set;
+  const seenEmotions = new Set;
+  let emitted = 0;
+  let evictionReported = false;
+  const rememberIn = (seen, capacity, key) => {
+    if (seen.has(key))
+      return false;
+    if (seen.size >= capacity) {
+      const iterator = seen.values();
+      for (let i = 0;i < Math.max(1, Math.floor(capacity / 10)); i++) {
+        const next = iterator.next();
+        if (next.done)
+          break;
+        seen.delete(next.value);
+      }
+      if (!evictionReported) {
+        evictionReported = true;
+        emitMeta({
+          type: "tail_dedupe_evicted",
+          capacity,
+          detail: "Dedupe memory reached capacity and oldest ids were dropped; items seen long ago may re-appear once. Restart the tail, or narrow --signal, if exact-once matters."
+        });
+      }
+    }
+    seen.add(key);
+    return true;
+  };
+  const rememberConversation = (key) => rememberIn(seenConversations, CONVERSATIONS_SEEN_MAX, key);
+  const rememberEmotion = (key) => rememberIn(seenEmotions, EMOTIONS_SEEN_MAX, key);
+  const emitsCoverage = signal === "emotions" || signal === "all";
+  const metaReserve = params.max_events !== undefined && emitsCoverage && params.max_events >= 2 ? 1 : 0;
+  const dataBudget = params.max_events === undefined ? undefined : Math.max(0, params.max_events - metaReserve);
+  const capReached = () => dataBudget !== undefined && emitted >= dataBudget;
+  const emitLine = (item) => {
+    if (capReached())
+      return;
+    console.log(JSON.stringify(item));
+    emitted++;
+  };
+  const emitMeta = (item) => {
+    if (params.max_events !== undefined && emitted >= params.max_events) {
+      safeWriteStderr(`${JSON.stringify(item)}
+`);
+      return;
+    }
+    console.log(JSON.stringify(item));
+    emitted++;
+  };
+  const pollConversations = async () => {
+    const data = await callDataAPI(`/conversations?time_range=1h&limit=${limit}`);
+    const record = asRecord(data) ?? {};
+    const rows = Array.isArray(record.conversations) ? record.conversations : [];
+    for (const row of [...rows].reverse()) {
+      const conversation = asRecord(row);
+      if (!conversation)
+        continue;
+      const id = asString(conversation.conversation_id) ?? asString(conversation.id);
+      if (!id)
+        continue;
+      const timestamp = asString(conversation.last_timestamp) ?? asString(conversation.timestamp) ?? asString(conversation.last_activity) ?? "";
+      const messageCount = asNumber(conversation.message_count);
+      if (capReached())
+        return;
+      if (!rememberConversation(`c:${id}:${timestamp}:${messageCount ?? ""}`))
+        continue;
+      emitLine({
+        type: "conversation",
+        conversation_id: id,
+        timestamp: timestamp || null,
+        message_count: messageCount,
+        environment: conversation.environment ?? null,
+        cluster_name: conversation.cluster_name ?? null,
+        summary: conversation.summary ?? null
+      });
+    }
+  };
+  const pollEmotions = async () => {
+    const maxPages = params.full_scan === true ? EMOTIONS_FULL_SCAN_MAX_PAGES : EMOTIONS_TAIL_MAX_PAGES;
+    const collected = [];
+    let offset = 0;
+    let pages = 0;
+    let truncated = false;
+    let total = null;
+    for (;; ) {
+      const data = await callDataAPI(`/emotions?days_back=1&limit=${EMOTIONS_TAIL_PAGE_SIZE}&offset=${offset}`);
+      const record = asRecord(data) ?? {};
+      const rows = Array.isArray(record.detections) ? record.detections : [];
+      collected.push(...rows.map((row) => asRecord(row)).filter((row) => row !== null));
+      pages++;
+      const pagination = asRecord(record.pagination) ?? {};
+      total = asNumber(pagination.total) ?? total;
+      const hasMore = pagination.has_more === true;
+      if (!hasMore || rows.length === 0)
+        break;
+      if (pages >= maxPages) {
+        truncated = true;
+        break;
+      }
+      if (offset + EMOTIONS_TAIL_PAGE_SIZE > EMOTIONS_OFFSET_CEILING) {
+        truncated = true;
+        break;
+      }
+      offset += EMOTIONS_TAIL_PAGE_SIZE;
+    }
+    collected.sort((a, b) => (asString(a.detected_at) ?? "").localeCompare(asString(b.detected_at) ?? ""));
+    for (const detection of collected) {
+      if (capReached())
+        break;
+      const detectionId = asString(detection.detection_id);
+      if (!detectionId || !rememberEmotion(`e:${detectionId}`))
+        continue;
+      emitLine({
+        type: "emotion",
+        detection_id: detectionId,
+        conversation_id: detection.conversation_id ?? null,
+        family: detection.family ?? null,
+        primary_cause: detection.primary_cause ?? null,
+        detected_at: detection.detected_at ?? null
+      });
+    }
+    if (truncated || total !== null && collected.length < total) {
+      const scanned = collected.length;
+      const coveragePct = total && total > 0 ? Math.round(scanned / total * 1000) / 10 : null;
+      emitMeta({
+        type: "tail_coverage",
+        signal: "emotions",
+        complete: false,
+        scanned,
+        total,
+        coverage_pct: coveragePct,
+        pages_scanned: pages,
+        detail: `Scanned ${scanned}${total !== null ? ` of ${total}` : ""} detection(s) in the last day` + `${coveragePct !== null ? ` (${coveragePct}%)` : ""}. /emotions is ranked by score with no ` + "time ordering or cursor, so this follows the highest-scoring detections and " + "lower-scoring ones may not appear. Use --full-scan for completeness (many more " + "requests, up to the API offset ceiling of 10000), or `moda emotions --offset=N` to page manually."
+      });
+    } else if (total !== null) {
+      emitMeta({
+        type: "tail_coverage",
+        signal: "emotions",
+        complete: true,
+        scanned: collected.length,
+        total,
+        coverage_pct: 100,
+        pages_scanned: pages,
+        detail: "Scanned the full window for this poll."
+      });
+    }
+  };
+  if (params.once !== true && context.output.mode === "human") {
+    console.error(`Tailing ${signal} every ${intervalMs / 1000}s (Ctrl-C to stop). One JSON line per new item.`);
+  }
+  for (;; ) {
+    if (signal === "conversations" || signal === "all")
+      await pollConversations();
+    if (signal === "emotions" || signal === "all")
+      await pollEmotions();
+    if (params.once === true)
+      break;
+    if (params.max_events !== undefined && emitted >= params.max_events)
+      break;
+    await new Promise((resolve2) => setTimeout(resolve2, intervalMs));
+  }
 }
 async function attachWorldState(rows) {
   return Promise.all(rows.map(async (row) => {
@@ -4130,6 +4480,23 @@ async function runCommand(command, positional, flags, positionals = positional ?
     case "clusters": {
       const args = flagsToArgs(flags);
       const params = ClustersSchema.parse(args);
+      if (params.search !== undefined || params.node_id !== undefined) {
+        const query2 = new URLSearchParams;
+        if (params.search !== undefined)
+          query2.set("q", params.search);
+        if (params.node_id !== undefined)
+          query2.set("node_id", params.node_id);
+        if (params.mode)
+          query2.set("mode", params.mode);
+        if (params.limit)
+          query2.set("limit", params.limit.toString());
+        const data2 = await callDataAPI(`/task-clusters/search?${query2.toString()}`);
+        const record = asRecord(data2) ?? {};
+        const matches = Array.isArray(record.matches) ? record.matches : [];
+        const warnings = params.node_id !== undefined && matches.length === 0 ? notFoundWarning("cluster", params.node_id, true) : [];
+        context.output.writeData(data2, warnings.length > 0 ? { warnings } : undefined);
+        break;
+      }
       const query = new URLSearchParams;
       if (params.parent_id)
         query.set("parent_id", params.parent_id);
@@ -4153,7 +4520,9 @@ async function runCommand(command, positional, flags, positionals = positional ?
         query.set("offset", params.offset.toString());
       const queryString = query.toString() ? `?${query.toString()}` : "";
       const data = await callDataAPI(`/clusters/${params.node_id}/conversations${queryString}`);
-      context.output.writeData(data);
+      const clusterRecord = asRecord(data) ?? {};
+      const warnings = notFoundWarning("cluster", params.node_id, clusterRecord.cluster === null || clusterRecord.cluster === undefined);
+      context.output.writeData(data, warnings.length > 0 ? { warnings } : undefined);
       break;
     }
     case "conversations": {
@@ -4211,7 +4580,16 @@ async function runCommand(command, positional, flags, positionals = positional ?
         query.set("include_tool_io", "true");
       const data = await callDataAPI(`/search?${query.toString()}`);
       recordSearchTelemetry(context, data);
-      context.output.writeData(data);
+      const searchRecord = asRecord(data) ?? {};
+      const degradeReason = asString(searchRecord.degrade_reason);
+      const actualMode = asString(searchRecord.search_mode);
+      const warnings = [];
+      if (degradeReason && degradeReason !== "none") {
+        warnings.push(`Search degraded to keyword mode (${degradeReason}): the requested ${params.mode ?? "hybrid"} ranking did not run, and keyword scores are not comparable to semantic scores. Retry, or use --mode=keyword with exact identifiers.`);
+      } else if (params.mode && actualMode && actualMode !== params.mode && params.mode !== "hybrid") {
+        warnings.push(`Search ran in ${actualMode} mode instead of the requested ${params.mode} mode.`);
+      }
+      context.output.writeData(data, warnings.length > 0 ? { warnings } : undefined);
       break;
     }
     case "world-state": {
@@ -4220,6 +4598,37 @@ async function runCommand(command, positional, flags, positionals = positional ?
       }
       const args = flagsToArgs(flags, "conversation_id", positional);
       const params = WorldStateSchema.parse(args);
+      if (params.snapshot === true && params.replay === true) {
+        throw new CliInputError("Choose either --snapshot or --replay, not both.", "Usage: moda world-state <conversation_id> [--snapshot --msg-index=N [--block-index=M] [--segment-index=K]] | [--replay --message-count=N [--format=frames|fold-inputs]]");
+      }
+      if (params.snapshot === true) {
+        const query2 = new URLSearchParams;
+        query2.set("msg_index", (params.msg_index ?? 0).toString());
+        if (params.block_index !== undefined)
+          query2.set("block_index", params.block_index.toString());
+        if (params.segment_index !== undefined)
+          query2.set("segment_index", params.segment_index.toString());
+        const data2 = await callDataAPI(`/conversations/${params.conversation_id}/world-state/snapshot?${query2.toString()}`);
+        const snapshotRecord = asRecord(data2) ?? {};
+        const warnings2 = notFoundWarning("world state", params.conversation_id, snapshotRecord.found === false);
+        context.output.writeData(data2, warnings2.length > 0 ? { warnings: warnings2 } : undefined);
+        break;
+      }
+      if (params.replay === true) {
+        const format = params.format ?? "frames";
+        if (format === "frames" && params.message_count === undefined) {
+          throw new CliInputError("--message-count=N is required with --replay in frames mode (the API returns no frames without it). Use --format=fold-inputs for the raw keyframes/events without a count.");
+        }
+        const query2 = new URLSearchParams;
+        query2.set("format", format === "fold-inputs" ? "fold_inputs" : "frames");
+        if (params.message_count !== undefined)
+          query2.set("message_count", params.message_count.toString());
+        const data2 = await callDataAPI(`/conversations/${params.conversation_id}/world-state/replay?${query2.toString()}`);
+        const replayRecord = asRecord(data2) ?? {};
+        const warnings2 = notFoundWarning("world state", params.conversation_id, replayRecord.hasData === false);
+        context.output.writeData(data2, warnings2.length > 0 ? { warnings: warnings2 } : undefined);
+        break;
+      }
       const query = new URLSearchParams;
       if (params.summary_only === true)
         query.set("summary_only", "1");
@@ -4227,7 +4636,9 @@ async function runCommand(command, positional, flags, positionals = positional ?
         query.set("event_limit", params.event_limit.toString());
       const queryString = query.toString() ? `?${query.toString()}` : "";
       const data = await callDataAPI(`/conversations/${params.conversation_id}/world-state${queryString}`);
-      context.output.writeData(data);
+      const wsRecord = asRecord(data) ?? {};
+      const warnings = notFoundWarning("world state", params.conversation_id, wsRecord.hasData === false);
+      context.output.writeData(data, warnings.length > 0 ? { warnings } : undefined);
       break;
     }
     case "context": {
@@ -4243,7 +4654,9 @@ async function runCommand(command, positional, flags, positionals = positional ?
         query.set("window", params.window.toString());
       const queryString = query.toString() ? `?${query.toString()}` : "";
       const data = await callDataAPI(`/conversations/${params.conversation_id}/context${queryString}`);
-      context.output.writeData(data);
+      const ctxRecord = asRecord(data) ?? {};
+      const warnings = notFoundWarning("conversation", params.conversation_id, asNumber(ctxRecord.total_messages) === 0);
+      context.output.writeData(data, warnings.length > 0 ? { warnings } : undefined);
       break;
     }
     case "audit":
@@ -4305,7 +4718,13 @@ async function runCommand(command, positional, flags, positionals = positional ?
         query.set("offset", params.offset.toString());
       const queryString = query.toString() ? `?${query.toString()}` : "";
       const data = await callDataAPI(`/tool-failures/${params.tool_name}${queryString}`);
-      await printWithOptionalWindows(withToolFailureAnchors(data), "examples", params.include_window === true, params.window ?? 1, context.output);
+      const tfRecord = asRecord(data) ?? {};
+      const subtypeCount = Array.isArray(tfRecord.subtypes) ? tfRecord.subtypes.length : 0;
+      const exampleCount = Array.isArray(tfRecord.examples) ? tfRecord.examples.length : 0;
+      const warnings = subtypeCount === 0 && exampleCount === 0 ? [
+        `No failures found for tool "${params.tool_name}" in the last ${params.days_back ?? 7} 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.`
+      ] : [];
+      await printWithOptionalWindows(withToolFailureAnchors(data), "examples", params.include_window === true, params.window ?? 1, context.output, warnings);
       break;
     }
     case "problems": {
@@ -4325,6 +4744,149 @@ async function runCommand(command, positional, flags, positionals = positional ?
       context.output.writeData(withLink);
       break;
     }
+    case "problem": {
+      if (!positional) {
+        throw new CliInputError("<problem_id> is required", "Usage: moda problem <problem_id> [--evidence|--reports|--conversations|--feedback] [--limit=N] [--cursor=TOKEN] [--family=F] [--door=D]");
+      }
+      const args = flagsToArgs(flags, "id", positional);
+      const params = ProblemSchema.parse(args);
+      const views = ["evidence", "reports", "conversations", "feedback"].filter((view2) => params[view2] === true);
+      if (views.length > 1) {
+        throw new CliInputError(`Choose at most one of --evidence, --reports, --conversations, --feedback (got ${views.map((v) => `--${v}`).join(" ")}).`, "Usage: moda problem <problem_id> [--evidence|--reports|--conversations|--feedback]");
+      }
+      const view = views[0];
+      if (view === undefined) {
+        const data2 = await callDataAPI(`/problems/${encodeURIComponent(params.id)}`);
+        const record = asRecord(data2) ?? {};
+        const warnings = record.found === false ? [
+          `No problem found for id "${params.id}" — it may not exist in this tenant, or may have been merged away (the API returns found:false rather than an error).`
+        ] : [];
+        context.output.writeData(data2, warnings.length > 0 ? { warnings } : undefined);
+        break;
+      }
+      if (!UUID_RE.test(params.id)) {
+        throw new CliInputError(`--${view} requires a canonical problem UUID; got "${params.id}". Run \`moda problems\` or \`moda problem <id>\` first to resolve the id.`);
+      }
+      const query = new URLSearchParams;
+      if (params.limit)
+        query.set("limit", params.limit.toString());
+      if (params.cursor)
+        query.set("cursor", params.cursor);
+      if (view === "conversations") {
+        if (params.family)
+          query.set("family", params.family);
+        if (params.door)
+          query.set("door", params.door);
+      }
+      const queryString = query.toString() ? `?${query.toString()}` : "";
+      const data = await callDataAPI(`/problems/${params.id}/${view}${queryString}`);
+      context.output.writeData(data);
+      break;
+    }
+    case "problem-feedback": {
+      if (!positional) {
+        throw new CliInputError("<problem_id> is required", `Usage: moda problem-feedback <problem_id> --action=${PROBLEM_FEEDBACK_ACTIONS.join("|")} [--reason=TEXT] [--attribution-id=UUID] [--new-name=NAME]`);
+      }
+      const params = ProblemFeedbackSchema.parse({
+        id: positional,
+        ...flags.action !== undefined ? { action: flags.action } : {},
+        ...flags.reason !== undefined ? { reason: flags.reason } : {},
+        ...flags["attribution-id"] !== undefined ? { attribution_id: flags["attribution-id"] } : {},
+        ...flags["new-name"] !== undefined ? { new_name: flags["new-name"] } : {},
+        ...flags.actor !== undefined ? { actor: flags.actor } : {}
+      });
+      if (!UUID_RE.test(params.id)) {
+        throw new CliInputError(`Problem id must be a canonical UUID; got "${params.id}".`);
+      }
+      const reason = params.reason?.trim() ?? "";
+      if ((params.action === "dismiss" || params.action === "flag_attribution") && reason === "") {
+        throw new CliInputError(`--reason is required for --action=${params.action}.`);
+      }
+      if (params.action === "rename" && (params.new_name?.trim() ?? "") === "") {
+        throw new CliInputError("--new-name is required for --action=rename.");
+      }
+      if (params.action === "flag_attribution") {
+        if (params.attribution_id === undefined || params.attribution_id.trim() === "") {
+          throw new CliInputError("--attribution-id=<uuid> is required for --action=flag_attribution. Run `moda problem <problem_id> --evidence` to list attribution ids.");
+        }
+        if (!UUID_RE.test(params.attribution_id)) {
+          throw new CliInputError("--attribution-id must be a UUID.");
+        }
+      }
+      const data = await callDataAPI(`/problems/${params.id}/feedback`, {
+        method: "POST",
+        body: JSON.stringify({
+          action: params.action,
+          ...reason !== "" ? { reason } : {},
+          ...params.attribution_id ? { attribution_id: params.attribution_id } : {},
+          ...params.new_name ? { new_display_name: params.new_name } : {},
+          actor: params.actor ?? "moda-cli"
+        }),
+        headers: { "Content-Type": "application/json" }
+      }, { retries: 0 });
+      context.output.writeData(data);
+      break;
+    }
+    case "emotions": {
+      const args = flagsToArgs(flags);
+      const params = EmotionsSchema.parse(args);
+      const query = new URLSearchParams;
+      if (params.days_back)
+        query.set("days_back", params.days_back.toString());
+      if (params.limit)
+        query.set("limit", params.limit.toString());
+      if (params.offset !== undefined)
+        query.set("offset", params.offset.toString());
+      if (params.family)
+        query.set("family", params.family);
+      const queryString = query.toString() ? `?${query.toString()}` : "";
+      const data = await callDataAPI(`/emotions${queryString}`);
+      context.output.writeData(data);
+      break;
+    }
+    case "hallucinations": {
+      const args = flagsToArgs(flags);
+      if (flags["conversation-id"] !== undefined) {
+        args.conversation_id = flags["conversation-id"];
+      }
+      const params = HallucinationsSchema.parse(args);
+      const query = new URLSearchParams;
+      if (params.days_back)
+        query.set("days_back", params.days_back.toString());
+      if (params.limit)
+        query.set("limit", params.limit.toString());
+      if (params.offset !== undefined)
+        query.set("offset", params.offset.toString());
+      if (params.conversation_id)
+        query.set("conversation_id", params.conversation_id);
+      if (params.kind)
+        query.set("kind", params.kind);
+      const queryString = query.toString() ? `?${query.toString()}` : "";
+      const data = await callDataAPI(`/hallucinations${queryString}`);
+      context.output.writeData(data);
+      break;
+    }
+    case "step-scores": {
+      if (!positional) {
+        throw new CliInputError("<conversation_id> is required", "Usage: moda step-scores <conversation_id>");
+      }
+      const params = StepScoresSchema.parse({ conversation_id: positional });
+      const data = await callDataAPI(`/conversations/${encodeURIComponent(params.conversation_id)}/step-scores`);
+      const record = asRecord(data) ?? {};
+      const steps = Array.isArray(record.steps) ? record.steps : [];
+      const segments = Array.isArray(record.segments) ? record.segments : [];
+      const warnings = steps.length === 0 && segments.length === 0 ? [
+        `No step scores found for conversation "${params.conversation_id}" — it may not exist in this tenant, or has not been scored yet.`
+      ] : [];
+      context.output.writeData(data, warnings.length > 0 ? { warnings } : undefined);
+      break;
+    }
+    case "tail": {
+      const args = flagsToArgs(flags);
+      const params = TailSchema.parse(args);
+      await runTailCommand(params, context);
+      break;
+    }
     case "feedback": {
       const note = positionals.join(" ").trim();
       if (note === "") {
@@ -4463,7 +5025,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-fm9ey3ks.js");
+      const { runInit } = await import("./index-efv643ec.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",
@@ -4504,7 +5066,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result-and-error",
     handler: async (context) => {
-      const { runProvision } = await import("./provision-dphktm75.js");
+      const { runProvision } = await import("./provision-r0cq3g2v.js");
       return runProvision(context, {
         resumeCommand: buildResumeCommand("provision", context.rawFlags)
       });
@@ -4775,6 +5337,65 @@ var commandRegistry = createCommandRegistry([
     examples: ["moda problems", "moda problems --days-back=7 --limit=10"],
     ...dataApiDefaults
   }),
+  legacyCommand({
+    name: "problem",
+    description: "Open one Problem: dossier, or --evidence/--reports/--conversations/--feedback pages",
+    examples: [
+      "moda problem <problem_id>",
+      "moda problem <problem_id> --evidence --limit=10",
+      "moda problem <problem_id> --reports",
+      "moda problem <problem_id> --conversations --family=tool_failure",
+      "moda problem <problem_id> --feedback"
+    ],
+    ...dataApiDefaults
+  }),
+  legacyCommand({
+    name: "problem-feedback",
+    description: "Submit Problem feedback: mark fixed, dismiss, rename, or flag a bad attribution",
+    examples: [
+      "moda problem-feedback <problem_id> --action=mark_fixed",
+      'moda problem-feedback <problem_id> --action=dismiss --reason="not actionable"',
+      'moda problem-feedback <problem_id> --action=rename --new-name="Better title"',
+      'moda problem-feedback <problem_id> --action=flag_attribution --attribution-id=<uuid> --reason="wrong conversation"'
+    ],
+    ...dataApiDefaults,
+    mutability: "write"
+  }),
+  legacyCommand({
+    name: "emotions",
+    description: "Multi-family emotion detections (frustration, sadness, confusion, anxiety, trust, positive)",
+    examples: [
+      "moda emotions --days-back=7",
+      "moda emotions --family=confusion --limit=20"
+    ],
+    ...dataApiDefaults
+  }),
+  legacyCommand({
+    name: "hallucinations",
+    description: "Grounding detections: contradicted/verified outputs with rule breakdown",
+    examples: [
+      "moda hallucinations --days-back=30",
+      "moda hallucinations --kind=contradicted --limit=20",
+      "moda hallucinations --conversation-id=<id>"
+    ],
+    ...dataApiDefaults
+  }),
+  legacyCommand({
+    name: "step-scores",
+    description: "Graph-PRM step scores for a conversation (per-segment curves, first bad step, rollup)",
+    examples: ["moda step-scores <conversation_id>"],
+    ...dataApiDefaults
+  }),
+  legacyCommand({
+    name: "tail",
+    description: "Live-tail new conversations and detections as NDJSON (one JSON line per item)",
+    examples: [
+      "moda tail",
+      "moda tail --signal=emotions --interval=30",
+      "moda tail --once"
+    ],
+    ...dataApiDefaults
+  }),
   legacyCommand({
     name: "feedback",
     description: "Flag wrong/missing data or CLI quirks to the Moda team",
@@ -4888,7 +5509,12 @@ async function dispatchParsedCommand(parsed, startedAt = Date.now()) {
     return 0;
   }
   if (command === "--help" || command === "-h" || flags.help === "true") {
-    printHelp();
+    const helpTarget = command && command !== "--help" && command !== "-h" ? commandRegistry.find(command) : undefined;
+    if (helpTarget) {
+      printCommandHelp(helpTarget);
+    } else {
+      printHelp();
+    }
     return 0;
   }
   if (command === "--json-schemas" || flags["json-schemas"] === "true") {
@@ -5069,5 +5695,6 @@ export {
   commandRegistry,
   classifyCliError,
   buildResumeCommand,
+  TAIL_LIMITS,
   CliInputError
 };

package/dist/{harness-github-actions-rjyc9a7z.js → harness-github-actions-ct8fwzdr.js}

@@ -1,7 +1,7 @@
 import {
   buildSourceSnapshot
-} from "./cli-jntzpem2.js";
-import"./cli-vc7zddj1.js";
+} from "./cli-g931ntph.js";
+import"./cli-59yacef3.js";
 
 // src/harness-github-actions.ts
 var DEFAULT_MODA_GITHUB_URL = "https://moda-github.modas.workers.dev";

package/dist/{index-fm9ey3ks.js → index-efv643ec.js}

@@ -9,7 +9,7 @@ import {
   runPromptSync,
   runSkillSync,
   upsertSkillManifestRecord
-} from "./cli-kqvjt12y.js";
+} from "./cli-xf5nx5hc.js";
 import {
   codingAgentDisplayName,
   describeCodingAgentEvent,
@@ -27,14 +27,14 @@ import {
   runHarnessCommand,
   startRemoteAnalyze,
   stripAnsi
-} from "./cli-jntzpem2.js";
+} from "./cli-g931ntph.js";
 import {
   selectTenantAndCreateKey
-} from "./cli-tdttb4cv.js";
+} from "./cli-pq6rte0w.js";
 import {
   loadToken,
   login
-} from "./cli-8s69sg7f.js";
+} from "./cli-9xw5bq1j.js";
 import {
   CliAuthError,
   CliInputError,
@@ -42,7 +42,7 @@ import {
   createCommandContext,
   resolveIngestUrl,
   resolveModaBaseUrl
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/init/index.ts
 import { existsSync as existsSync6, mkdirSync as mkdirSync5, readdirSync as readdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";

package/dist/{provision-dphktm75.js → provision-r0cq3g2v.js}

@@ -1,15 +1,15 @@
 import {
   selectTenantAndCreateKey
-} from "./cli-tdttb4cv.js";
+} from "./cli-pq6rte0w.js";
 import {
   loadAuthSession
-} from "./cli-8s69sg7f.js";
+} from "./cli-9xw5bq1j.js";
 import {
   CliAuthError,
   resolveIngestUrl,
   resolveModaBaseUrl,
   stringOption
-} from "./cli-vc7zddj1.js";
+} from "./cli-59yacef3.js";
 
 // src/provision.ts
 async function runProvision(context, options = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.25.0",
+  "version": "1.26.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-28T04:14:38.909Z",
-  "cli_version": "1.25.0",
+  "bundled_at": "2026-08-17T00:50:53.917Z",
+  "cli_version": "1.26.0",
   "skills": [
     {
       "id": "integration-node-anthropic",

package/skills/moda-cli/SKILL.md

@@ -16,7 +16,7 @@ or promote remote state (`prompts sync`, `prompts promote`).
 
 **`moda search` is the primary way to find anything by content.** It runs
 message-grain semantic, keyword, or hybrid retrieval across every message —
-including tool calls and tool results — and returns ranked snippets with
+including tool calls and tool results with `--include-tool-io` — and returns ranked snippets with
 direct anchors (`conversation_id` + `message_index`) you can hand straight to
 `moda context`. Reach for it first whenever the question is "where did X
 happen?" or "find conversations/tool calls about Y". Use `moda conversations`
@@ -55,9 +55,9 @@ Optional:
 
 - `MODA_BASE_URL` defaults to `https://moda.dev`; override only for
   self-hosted or staging.
-- `MODA_SKILL_VERSION` — export to `2.0.0` so search-adoption telemetry can
+- `MODA_SKILL_VERSION` — export to `2.2.0` so search-adoption telemetry can
   attribute usage to this skill version. Set it once per session:
-  `export MODA_SKILL_VERSION=2.0.0`.
+  `export MODA_SKILL_VERSION=2.2.0`.
 
 ## Setup
 
@@ -391,9 +391,10 @@ moda search "checkout error" --time-range=7d --limit=10
 moda search "stripe.charges.create failed" --user-id=<id>
 ```
 
-Searches conversation messages at message grain, **including tool calls and
-tool results** (tool name, input arguments, and output previews are embedded),
-so it finds where an agent *did* something, not just where it talked about it.
+Searches conversation messages at message grain. Pass `--include-tool-io` to
+also search **tool calls and tool results** (tool name, input arguments, and
+output previews), so it finds where an agent *did* something, not just where
+it talked about it — tool-IO search is opt-in, not the default.
 
 Flags: `--mode=keyword|semantic|hybrid` (default `hybrid`), `--user-id`,
 `--time-range` (`all|1h|3d|7d|24h|30d|90d`, default `all`), `--limit` (1–100,
@@ -710,9 +711,10 @@ moda feedback "a cancelled call is counted as a tool failure" \
 ## Validation — how to know it worked
 
 - Every successful command exits 0 and prints valid JSON to stdout.
-- `moda ask` / `moda investigate` may exit `3` (degraded): a real,
-  lower-trust answer synthesized from local evidence — not a failure. Treat
-  exit `1` as the only hard error (see [Agent protocol](#agent-protocol)).
+- `moda ask` may exit `3` (degraded): a real, lower-trust answer synthesized
+  from local evidence — not a failure (`investigate`/`failures` always exit
+  `0` on success). Treat exit `1` as the only hard error (see
+  [Agent protocol](#agent-protocol)).
 - Errors print to stderr with non-zero exit. Check stderr before claiming
   success.
 - If the JSON has `"conversations": []` or `"frustrations": []`, the call
@@ -768,13 +770,22 @@ npx: `npx -p @moda-ai/cli moda <command>`.
 | `moda overview` | Dashboard KPIs, top clusters, recent activity |
 | `moda ask "<question>"` | Natural-language production/harness answer with evidence (exit `3` = degraded local fallback) |
 | `moda investigate` | Rank production issues with evidence + next commands |
-| `moda clusters` | Browse topic cluster hierarchy |
+| `moda clusters` | Browse topic cluster hierarchy; `--search="q"` finds clusters by meaning, `--node-id=ID` resolves a deep link |
 | `moda cluster-conversations <node_id>` | Conversations in a cluster |
 | `moda conversations` | List/filter conversations by structured fields |
 | `moda context <conversation_id>` | Windowed message context (max 5 per side) |
-| `moda frustrations` | User frustration detections with evidence |
+| `moda frustrations` | User frustration detections with evidence (legacy single-family; prefer `emotions`) |
+| `moda emotions` | Multi-family emotion detections: frustration, sadness, confusion, anxiety, trust, positive (`--family=F`, limit 1–20) |
+| `moda hallucinations` | Grounding detections: contradicted/verified outputs, rule breakdown (`--kind=contradicted\|verified`, `--conversation-id=ID`) |
 | `moda tool-failures` | Tool failure overview |
 | `moda tool-failure-detail <tool_name>` | Per-tool failure breakdown + examples |
+| `moda problems` | Rank cross-signal Problems by root cause (what to fix first) |
+| `moda problem <problem_id>` | One Problem: dossier, or `--evidence`/`--reports`/`--conversations`/`--feedback` pages (`--limit` 1–50, `--cursor` verbatim keyset token) |
+| `moda problem-feedback <problem_id>` | Write: `--action=mark_fixed\|dismiss\|flag_attribution\|rename`. `--reason` required for dismiss/flag_attribution; `--new-name` for rename; `--attribution-id` (UUID) required for flag_attribution |
+| `moda step-scores <conversation_id>` | Graph-PRM step scores: per-segment curves, first bad step, rollup |
+| `moda world-state <conversation_id>` | Agent memory: slots/threads/events; `--summary-only`; `--snapshot --msg-index=N` (state at a turn); `--replay --message-count=N` (state over time) |
+| `moda failures` | Production failures worth fixing first |
+| `moda tail` | Live tail: one JSON line per new conversation/detection (`--signal=conversations\|emotions\|all`, `--interval=N`, `--once`, `--max-events=N`). **Emotions caveat:** `/emotions` is ranked by score with no time ordering or cursor, so the tail follows the *highest-scoring* detections rather than everything; each poll emits a `tail_coverage` line with `scanned`/`total`/`coverage_pct`/`complete`. Pass `--full-scan` for a complete window scan (many more requests, capped by the API's offset ceiling of 10000). |
 | `moda feedback "<note>"` | Flag wrong/missing data or CLI quirks to the Moda team |
 | `moda prompts status` | Read-only local prompt status |
 | `moda prompts diff` | Read-only local prompt diff/status |