@moda-ai/cli 1.35.0 → 1.36.0

package/dist/cli.js

@@ -234,6 +234,46 @@ var DetectionReviewSchema = z.object({
   verdict: z.enum(DETECTION_VERDICTS),
   note: z.string().max(2000).optional()
 });
+var FALSE_POSITIVE_KINDS = ["problem", "problem-detection", "quote", "tool", "laziness", "hallucination", "custom-signal"];
+var FalsePositiveSchema = z.object({
+  kind: z.enum(FALSE_POSITIVE_KINDS),
+  target: z.string().min(1).max(255),
+  undo: z.boolean(),
+  reason: z.string().max(2000).optional(),
+  conversation_id: z.string().min(1).max(255).optional(),
+  attribution_id: z.string().regex(UUID_RE, "Attribution id must be a UUID").optional(),
+  family: z.string().regex(/^[a-z_]{1,64}$/, "Family must be a lowercase emotion family").optional(),
+  turn: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).optional()),
+  quote: z.string().min(1).max(4000).optional(),
+  tool: z.string().min(1).max(255).optional(),
+  tool_use_id: z.string().min(1).max(255).optional(),
+  msg_index: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).optional()),
+  msg_dedup_token: z.string().min(1).max(200).optional()
+}).superRefine((v, ctx) => {
+  const need = (ok, message) => {
+    if (!ok)
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message });
+  };
+  if (v.kind === "problem") {
+    need(UUID_RE.test(v.target), "Problem id must be a canonical UUID");
+    need(!v.undo, "A problem dismissal cannot be undone from the CLI");
+  }
+  if (v.kind === "problem-detection") {
+    need(UUID_RE.test(v.target), "Problem id must be a canonical UUID");
+    need(v.conversation_id, "--conversation-id is required for problem-detection");
+    need(v.attribution_id, "--attribution-id is required for problem-detection");
+  }
+  if (v.kind === "quote") {
+    need(v.family && v.turn !== undefined && v.quote, "--family, --turn and --quote are required for quote (copy them from moda emotions)");
+  }
+  if (v.kind === "tool") {
+    need(v.tool, "--tool is required for tool (the failing tool name)");
+    need(v.tool_use_id || v.msg_index !== undefined, "--tool-use-id or --msg-index is required for tool (from moda tool-failure-detail)");
+  }
+  if (v.kind === "custom-signal") {
+    need(v.conversation_id, "--conversation-id is required for custom-signal");
+  }
+});
 var EMOTION_FAMILIES = [
   "frustration",
   "sadness",
@@ -255,6 +295,13 @@ var HallucinationsSchema = z.object({
   conversation_id: z.string().max(200).optional(),
   kind: z.enum(["contradicted", "verified"]).optional()
 });
+var LazinessSchema = z.object({
+  days_back: z.number().min(1).max(90).default(7).optional(),
+  limit: z.number().min(1).max(50).default(10).optional(),
+  offset: z.number().min(0).max(1e4).optional(),
+  conversation_id: z.string().max(200).optional(),
+  family: z.string().regex(/^[a-z_]{1,64}$/, "Family must be a lowercase laziness family").optional()
+});
 var StepScoresSchema = z.object({
   conversation_id: z.string().min(1)
 });
@@ -5401,12 +5448,15 @@ Commands:
   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
+  laziness                         Laziness detections per trace (repeated calls, premature handoffs, ...)
   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-impact                   Live problem/use-case impact (--node-id, --problem-id, --mode, --days-back)
   problem <problem_id>             Open one Problem: dossier, or --evidence/--reports/--traces/--feedback
   problem-feedback <problem_id>    Mark a Problem fixed, dismiss, rename, or flag a bad attribution
+  false-positive <kind> <target>   Mark any detection as a false positive, optional --reason (problem, problem-detection, quote, tool, laziness, hallucination, custom-signal)
+  false-positives [conv_id]        Current false-positive marks: all (--kind, --all, --limit) or one trace
   detection-reviews <conv_id>      Problem detections on a trace with their review state
   detection-review <problem_id>    Mark a problem detection correct, a false positive, or clear the review
   signals                          List custom signals (name, criteria, status, 7-day stats)
@@ -5516,6 +5566,11 @@ Emotions flags:
   --days-back=N --limit=N          Window 1-90 (default 7); page size 1-20 (default 10)
   --offset=N                       Skip N detections (0-10000)
 
+Laziness flags:
+  --family=F                       Narrow to one laziness family
+  --conversation-id=ID             One trace's detections
+  --days-back=N --limit=N          Window 1-90 (default 7); page size 1-50 (default 10)
+
 Hallucinations flags:
   --kind=contradicted|verified     Narrow the detections list
   --conversation-id=ID             Scope summary + list to one trace ID
@@ -5529,10 +5584,21 @@ Problem flags (moda problem <id>):
 
 Problem-feedback flags:
   --action=A                       mark_fixed|dismiss|flag_attribution|rename (required)
-  --reason=TEXT                    Required for dismiss and flag_attribution
+  --reason=TEXT                    Required for flag_attribution; optional for dismiss
   --attribution-id=UUID            Required for flag_attribution (ids come from problem --evidence)
   --new-name=NAME                  Required for rename
 
+False-positive flags (moda false-positive <kind> <target>):
+  --reason=TEXT                    Why it is wrong (optional)
+  --undo                           Remove an earlier mark (every kind except problem)
+  problem <problem_id>             Dismiss the problem: hidden at once, logged for review, folded into reconcile
+  problem-detection <problem_id>   One detection on a trace; needs --conversation-id and --attribution-id; teaches the problem
+  quote <conversation_id>          A user quote; needs --family, --turn and --quote (from moda emotions); audit only
+  tool <conversation_id>           One failing tool call; needs --tool and --tool-use-id (or --msg-index); audit only
+  laziness <conversation_id>       Laziness on that trace; audit only
+  hallucination <conversation_id>  Hallucinations on that trace; audit only
+  custom-signal <signal_id>        A hit on that trace (--conversation-id); saved as does_not_fit so the signal learns
+
 Detection-review flags (moda detection-review <problem_id>):
   --conversation-id=ID             Trace the detection is on (required)
   --attribution-id=UUID            Detection id (from problem --evidence or detection-reviews; required)
@@ -6404,7 +6470,7 @@ async function runCommand(command, positional, flags, positionals = positional ?
         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 === "") {
+      if (params.action === "flag_attribution" && reason === "") {
         throw new CliInputError(`--reason is required for --action=${params.action}.`);
       }
       if (params.action === "rename" && (params.new_name?.trim() ?? "") === "") {
@@ -6538,6 +6604,99 @@ async function runCommand(command, positional, flags, positionals = positional ?
       context.output.writeData(data);
       break;
     }
+    case "false-positive": {
+      const usage = `Usage: moda false-positive <${FALSE_POSITIVE_KINDS.join("|")}> <target> --reason=TEXT [--undo]`;
+      const [kind, target] = positionals;
+      if (!kind || !target)
+        throw new CliInputError("<kind> and <target> are required", usage);
+      const params = FalsePositiveSchema.parse({
+        kind,
+        target,
+        undo: flags.undo !== undefined && flags.undo !== "false",
+        ...flags.reason !== undefined ? { reason: flags.reason } : {},
+        ...flags["conversation-id"] !== undefined ? { conversation_id: flags["conversation-id"] } : {},
+        ...flags["attribution-id"] !== undefined ? { attribution_id: flags["attribution-id"] } : {},
+        ...flags.family !== undefined ? { family: flags.family } : {},
+        ...flags.turn !== undefined ? { turn: flags.turn } : {},
+        ...flags.quote !== undefined ? { quote: flags.quote } : {},
+        ...flags.tool !== undefined ? { tool: flags.tool } : {},
+        ...flags["tool-use-id"] !== undefined ? { tool_use_id: flags["tool-use-id"] } : {},
+        ...flags["msg-index"] !== undefined ? { msg_index: flags["msg-index"] } : {},
+        ...flags["msg-dedup-token"] !== undefined ? { msg_dedup_token: flags["msg-dedup-token"] } : {}
+      });
+      const reason = params.reason?.trim() ?? "";
+      const post = (path, body, retries) => callDataAPI(path, { method: "POST", body: JSON.stringify(body), headers: { "Content-Type": "application/json" } }, retries === undefined ? undefined : { retries });
+      let data;
+      switch (params.kind) {
+        case "problem":
+          data = await post(`/problems/${params.target}/feedback`, { action: "dismiss", reason, actor: "moda-cli" }, 0);
+          break;
+        case "problem-detection":
+          data = await post(`/problems/${params.target}/detection-reviews`, {
+            conversation_id: params.conversation_id,
+            attribution_id: params.attribution_id,
+            verdict: params.undo ? "clear" : "false_positive",
+            ...params.undo ? {} : { note: reason },
+            request_nonce: randomUUID2()
+          });
+          break;
+        case "custom-signal":
+          if (params.undo) {
+            data = await callDataAPI(`/custom-signals/${encodeURIComponent(params.target)}/labels/${encodeURIComponent(params.conversation_id ?? "")}`, { method: "DELETE" }, { retries: 0 });
+            break;
+          }
+          data = await post(`/custom-signals/${encodeURIComponent(params.target)}/labels`, {
+            conversation_id: params.conversation_id,
+            label: "does_not_fit",
+            note: reason,
+            ...params.msg_index !== undefined ? { msg_index: params.msg_index } : {},
+            ...params.msg_dedup_token ? { msg_dedup_token: params.msg_dedup_token } : {}
+          }, 0);
+          break;
+        default: {
+          const apiKind = { quote: "frustration_quote", tool: "tool_call", laziness: "laziness", hallucination: "hallucination" }[params.kind];
+          data = await post("/false-positives", {
+            kind: apiKind,
+            verdict: params.undo ? "clear" : "false_positive",
+            ...params.undo ? {} : { note: reason },
+            conversation_id: params.target,
+            ...params.kind === "tool" ? {
+              tool_name: params.tool,
+              ...params.tool_use_id ? { tool_use_id: params.tool_use_id } : { msg_index: params.msg_index }
+            } : {},
+            ...params.kind === "quote" ? { family: params.family, turn: params.turn, quote: params.quote } : {},
+            request_nonce: randomUUID2()
+          });
+        }
+      }
+      context.output.writeData(data);
+      break;
+    }
+    case "false-positives": {
+      if (!positional) {
+        const kinds = { quote: "frustration_quote", tool: "tool_call", laziness: "laziness", hallucination: "hallucination", "custom-signal": "custom_signal" };
+        const query = new URLSearchParams;
+        if (flags.kind !== undefined) {
+          if (!kinds[flags.kind])
+            throw new CliInputError(`--kind must be one of ${Object.keys(kinds).join("|")}`);
+          query.set("kind", kinds[flags.kind]);
+        }
+        if (flags.limit !== undefined) {
+          if (!/^\d+$/.test(flags.limit) || Number(flags.limit) < 1 || Number(flags.limit) > 200)
+            throw new CliInputError("--limit must be 1-200");
+          query.set("limit", flags.limit);
+        }
+        if (flags.all !== undefined && flags.all !== "false")
+          query.set("include_cleared", "true");
+        const queryString = query.toString() ? `?${query.toString()}` : "";
+        const data2 = await callDataAPI(`/false-positives${queryString}`);
+        context.output.writeData(data2);
+        break;
+      }
+      const data = await callDataAPI(`/conversations/${encodeURIComponent(positional)}/false-positives`);
+      context.output.writeData(data);
+      break;
+    }
     case "emotions": {
       const args = flagsToArgs(flags);
       const params = EmotionsSchema.parse(args);
@@ -6555,6 +6714,28 @@ async function runCommand(command, positional, flags, positionals = positional ?
       context.output.writeData(data);
       break;
     }
+    case "laziness": {
+      const args = flagsToArgs(flags);
+      if (flags["conversation-id"] !== undefined) {
+        args.conversation_id = flags["conversation-id"];
+      }
+      const params = LazinessSchema.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.family)
+        query.set("family", params.family);
+      const queryString = query.toString() ? `?${query.toString()}` : "";
+      const data = await callDataAPI(`/laziness${queryString}`);
+      context.output.writeData(data);
+      break;
+    }
     case "hallucinations": {
       const args = flagsToArgs(flags);
       if (flags["conversation-id"] !== undefined) {
@@ -7181,6 +7362,32 @@ var commandRegistry = createCommandRegistry([
     ...dataApiDefaults,
     mutability: "write"
   }),
+  legacyCommand({
+    name: "false-positive",
+    description: "Flag a detection as a false positive with a reason: problem, problem-detection, quote, tool, laziness, hallucination, or custom-signal",
+    examples: [
+      'moda false-positive problem <problem_id> --reason="two unrelated tools"',
+      'moda false-positive problem-detection <problem_id> --conversation-id=<id> --attribution-id=<uuid> --reason="refund was approved"',
+      'moda false-positive quote <conversation_id> --family=frustration --turn=3 --quote="this is useless lol" --reason="joking"',
+      'moda false-positive tool <conversation_id> --tool=send_invoice --tool-use-id=<id> --reason="retried upstream"',
+      'moda false-positive laziness <conversation_id> --reason="reload after context reset is expected"',
+      "moda false-positive hallucination <conversation_id> --undo",
+      "moda false-positive custom-signal <signal_id> --conversation-id=<id> --undo",
+      'moda false-positive custom-signal <signal_id> --conversation-id=<id> --reason="refund was approved"'
+    ],
+    ...dataApiDefaults,
+    mutability: "write"
+  }),
+  legacyCommand({
+    name: "false-positives",
+    description: "List current false-positive marks across the workspace, or on one trace (with problem detection reviews)",
+    examples: [
+      "moda false-positives",
+      "moda false-positives --kind=tool --all",
+      "moda false-positives <conversation_id>"
+    ],
+    ...dataApiDefaults
+  }),
   legacyCommand({
     name: "signals",
     description: "List custom signals with criteria, status, and 7-day judged/matched stats",
@@ -7221,6 +7428,15 @@ var commandRegistry = createCommandRegistry([
     ],
     ...dataApiDefaults
   }),
+  legacyCommand({
+    name: "laziness",
+    description: "Laziness detections per trace: repeated tool calls, premature handoffs, and other lazy patterns",
+    examples: [
+      "moda laziness --days-back=30",
+      "moda laziness --conversation-id=<id>"
+    ],
+    ...dataApiDefaults
+  }),
   legacyCommand({
     name: "hallucinations",
     description: "Grounding detections: contradicted/verified outputs with rule breakdown",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.35.0",
+  "version": "1.36.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-09-26T21:50:32.589Z",
-  "cli_version": "1.35.0",
+  "bundled_at": "2026-09-27T08:58:32.181Z",
+  "cli_version": "1.36.0",
   "skills": [
     {
       "id": "integration-cloudflare-think",

package/skills/moda-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: moda-cli
-version: 2.6.0
+version: 2.7.0
 description: Query Moda's AI agent trace analytics and manage code-first prompt versions from the terminal — semantic/keyword/hybrid message search, overview KPIs, topic clusters, message context, user frustration detections, tool failures, custom signals, false-positive review of detections, and moda prompts status/sync/promote. Use when the user asks about moda, modaflows, trace or conversation analytics, prompt management, user frustrations, agent observability, tool failure debugging, custom signals, marking a detection as a false positive, wants to find traces or tool calls about a topic, or wants to investigate how their AI agent is performing.
 ---
 
@@ -750,6 +750,45 @@ Rules that keep the proof honest:
 
 ### 9. Custom signals and false positives
 
+**Mark anything as a false positive with one command.** `--reason` (why the
+detection is wrong) is optional but recommended; marks are logged for Moda's review.
+A marked item disappears from every list and count (`moda problems`,
+`hallucinations`, `laziness`, `tool-failures`, problem evidence, the dashboard);
+`--undo` brings it back.
+
+```bash
+moda false-positive problem <problem_id> --reason="two unrelated tools"   # dismiss: hidden at once
+moda false-positive problem-detection <problem_id> --conversation-id=<id> \
+  --attribution-id=<uuid> --reason="refund was approved"                  # one piece of evidence
+moda false-positive quote <conversation_id> --family=frustration --turn=3 \
+  --quote="this is useless lol" --reason="user was joking"               # one user quote
+moda false-positive tool <conversation_id> --tool=send_invoice \
+  --tool-use-id=<tool_use_id> --reason="retried upstream"               # one failing tool call
+moda false-positive laziness <conversation_id> --reason="reload is expected"
+moda false-positive hallucination <conversation_id> --reason="price came from the tool result"
+moda false-positive custom-signal <signal_id> --conversation-id=<id> --reason="refund was approved"
+moda false-positive laziness <conversation_id> --undo                    # remove a mark (any kind but problem)
+moda false-positives                                                     # every current mark (--kind=tool, --all, --limit)
+moda false-positives <conversation_id>                                   # marks + problem reviews on a trace
+```
+
+What each flag does downstream:
+
+| Kind | Effect |
+|---|---|
+| `problem` | Dismisses the problem: it leaves `moda problems` and the dashboard at once, and the reason is folded into the next reconcile. Cannot be undone from the CLI |
+| `problem-detection` | Drops that evidence from the problem and teaches the problem reader (same as `detection-review --verdict=false_positive`) |
+| `custom-signal` | Saved as a `does_not_fit` label with the reason, so the signal learns from it and the live match is retracted (same as `signal-label`). `--undo` removes the label |
+| `quote`, `tool`, `laziness`, `hallucination` | Audit only: recorded for review, never fed back to the detectors |
+
+Find targets with the read commands: `--family`, `--turn` and `--quote` verbatim
+from a `user_quotes` entry in `moda emotions`; a failing call's `tool_use_id` (or `msg_index` when it has none) from
+`moda tool-failure-detail <tool_name>`;
+laziness traces from `moda laziness`; hallucination traces from
+`moda hallucinations`; custom-signal hits from `moda trace-signals` or
+`moda signal <id> --detections`; problem evidence ids from
+`moda problem <id> --evidence`.
+
 **Custom signals** are tenant-defined behaviors (pass/fail criteria) judged on
 every trace. Read them, then label hits so the signal learns:
 
@@ -768,7 +807,7 @@ match; `--label=fits` confirms it. Pass the hit's `anchor_msg_index` (or
 message, and always give a `--note` when rejecting. Labels are throttled to 10
 per minute per API key and are never retried automatically.
 
-**Problem detections** (the dashboard's thumbs on a trace) are reviewed with
+**Problem detections** (the dashboard's flag on problem evidence) are reviewed with
 `detection-review`. A `false_positive` drops the detection out of
 `moda problem <id> --evidence` and is fed back to the problem reader; `clear`
 undoes an earlier review.
@@ -954,7 +993,10 @@ npx: `npx -p @moda-ai/cli moda <command>`.
 | `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`/`--traces`/`--feedback` pages (`--conversations` is a legacy alias of `--traces`) (`--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 problem-feedback <problem_id>` | Write: `--action=mark_fixed\|dismiss\|flag_attribution\|rename`. `--reason` required for flag_attribution, optional for dismiss; `--new-name` for rename; `--attribution-id` (UUID) required for flag_attribution |
+| `moda false-positive <kind> <target>` | Write: kinds `problem\|problem-detection\|quote\|tool\|laziness\|hallucination\|custom-signal`; `--reason` optional; problem-detection needs `--conversation-id` + `--attribution-id`; quote needs `--family`, `--turn`, `--quote`; tool needs `--tool` plus `--tool-use-id` or `--msg-index`; custom-signal needs `--conversation-id`; `--undo` removes a mark (not for problem) |
+| `moda false-positives [conversation_id]` | Current false-positive marks: all (`--kind`, `--all` to include removed, `--limit`) or one trace with its problem detection reviews |
+| `moda laziness` | Laziness detections per trace (`--days-back`, `--limit` 1-50, `--conversation-id`, `--family`) |
 | `moda detection-reviews <conversation_id>` | Problem detections on a trace with review state (`--attribution-id=UUID` narrows to one) |
 | `moda detection-review <problem_id>` | Write: `--conversation-id`, `--attribution-id` (UUID), `--verdict=correct\|false_positive\|clear`, optional `--note` |
 | `moda signals` | Custom signals: criteria, status, 7-day judged/matched stats |