@moda-ai/cli 1.55.18 → 1.55.19

package/dist/cli-cehskjde.js

@@ -0,0 +1,1302 @@
+import {
+  ApiError,
+  callControlAPI,
+  callDataAPI
+} from "./cli-rqk6f6n6.js";
+import {
+  isPlatformApiKey,
+  setPlatformTenantOverride
+} from "./cli-7ea02wca.js";
+import {
+  CliAccessError,
+  CliInputError,
+  embeddedTenantIdFromApiKey,
+  resolveApiKey,
+  resolveApiTenantId
+} from "./cli-5ke3xe6y.js";
+
+// src/schemas.ts
+import { z } from "zod";
+var boolFlag = () => z.preprocess((val) => {
+  const text = String(val).toLowerCase();
+  if (["true", "1", "yes", "on"].includes(text))
+    return true;
+  if (["false", "0", "no", "off"].includes(text))
+    return false;
+  return val;
+}, z.boolean()).optional();
+var DAYS_BACK_MESSAGE = "must be a whole number from 1 to 90 (e.g. --days-back=7)";
+var daysBackFlag = (fallback) => {
+  const days = z.number({ invalid_type_error: DAYS_BACK_MESSAGE }).int(DAYS_BACK_MESSAGE).min(1, DAYS_BACK_MESSAGE).max(90, DAYS_BACK_MESSAGE);
+  const flag = fallback === undefined ? days.optional() : days.default(fallback).optional();
+  return flag.describe("Whole days to look back");
+};
+var ISO_BOUND_MESSAGE = "must be an ISO 8601 date (2026-10-07) or datetime (2026-10-07T14:30:00Z)";
+var ISO_BOUND = /^\d{4}-\d{2}-\d{2}(?:[Tt ]\d{2}:\d{2}(?::\d{2}(?:\.\d{1,9})?)?(?:[Zz]|[+-]\d{2}:?\d{2})?)?$/;
+var isoBoundFlag = () => z.string().trim().regex(ISO_BOUND, ISO_BOUND_MESSAGE).optional();
+var OverviewSchema = z.object({
+  days_back: daysBackFlag(7)
+});
+var ClustersSchema = z.object({
+  parent_id: z.string().optional().describe("List the children of this cluster node"),
+  time_range: z.enum(["all", "1h", "3d", "7d", "24h", "30d", "90d"]).default("all").optional().describe("Time window"),
+  search: z.string().min(2).max(200).optional().describe("Find clusters by name or meaning"),
+  node_id: z.string().min(1).max(512).optional().describe("Resolve one cluster node by id (deep link)"),
+  mode: z.enum(["fuzzy", "semantic", "hybrid"]).optional().describe("Cluster search mode (server default hybrid)"),
+  limit: z.number().min(1).max(50).optional().describe("Maximum clusters to return (with --search/--node-id)")
+});
+var ClusterConversationsSchema = z.object({
+  node_id: z.string().describe("Cluster node id (from moda clusters)"),
+  limit: z.number().min(1).max(100).default(10).optional().describe("Maximum traces to return"),
+  offset: z.number().min(0).default(0).optional().describe("Number of traces to skip")
+});
+var ConversationsSchema = z.object({
+  search: z.string().optional().describe("Ranked trace search (hybrid when embeddings exist, else keyword)"),
+  cluster_id: z.string().optional().describe("Only traces in this cluster node"),
+  user_id: z.string().optional().describe("Only traces from this end user"),
+  time_range: z.enum(["all", "1h", "3d", "24h", "7d", "30d", "90d"]).default("all").optional().describe("Time window"),
+  since: isoBoundFlag().describe("Absolute UTC start, inclusive (ISO date or datetime); intersected with --time-range"),
+  until: isoBoundFlag().describe("Absolute UTC end, inclusive (ISO date or datetime; a date covers that whole day)"),
+  environment: z.enum(["all", "development", "staging", "production"]).default("all").optional().describe("Only traces from this environment"),
+  world_state: z.string().max(200).optional().describe("Match world-state content (slots + durable profile); comma = AND"),
+  outcome: z.enum(["any", "positive", "negative"]).default("any").optional().describe("Filter by trace outcome (trajectory + frustration)"),
+  include_world_state: boolFlag().describe("Attach each result's world-state summary"),
+  sort: z.enum(["recent", "longest", "slowest"]).optional().describe("recent = newest activity, longest = most messages, slowest = longest span"),
+  limit: z.number().min(1).max(100).default(20).optional().describe("Maximum traces to return"),
+  offset: z.number().min(0).default(0).optional().describe("Number of traces to skip")
+});
+var WorldStateSchema = z.object({
+  conversation_id: z.string().describe("Trace ID"),
+  summary_only: boolFlag().describe("Segment summaries only (omit the event stream)"),
+  event_limit: z.number().min(1).max(5000).default(2000).optional().describe("Maximum world-state events to return"),
+  snapshot: boolFlag().describe("Folded slots at one tick (what the agent believed at that turn)"),
+  msg_index: z.number().min(0).max(1e5).optional().describe("Snapshot tick: message index (default 0)"),
+  block_index: z.number().min(0).max(1e5).optional().describe("Snapshot tick: content block index (default 0)"),
+  segment_index: z.number().min(0).max(65535).optional().describe("Scope the snapshot to one segment"),
+  replay: boolFlag().describe("State-over-time replay (frames mode needs --message-count)"),
+  format: z.enum(["frames", "fold-inputs"]).optional().describe("Replay format (default frames)"),
+  message_count: z.number().min(1).max(1e6).optional().describe("Messages to fold in frames mode")
+});
+var ContextSchema = z.object({
+  conversation_id: z.string().min(1).describe("Trace ID"),
+  msg_index: z.number().int().min(0).optional().describe("Anchor message index (default: middle of the trace)"),
+  window: z.number().int().min(0).optional().describe("Messages on each side of the anchor (above 5 is clamped)"),
+  metadata_only: boolFlag().describe("Summary and total_messages only, no messages"),
+  all: boolFlag().describe("Whole transcript in order (first 500 messages by default)"),
+  from: z.number().int().min(0).optional().describe("With --all: first message index to read"),
+  max_messages: z.number().int().min(1).max(5000).optional().describe("With --all: maximum messages to read (default 500)"),
+  ids_from: z.string().min(1).optional().describe("Read several targets (<id> or <id>@<msg_index>), one per line, from a file or - for stdin (batch mode, up to 25)")
+});
+var FrustrationsSchema = z.object({
+  days_back: daysBackFlag(7),
+  limit: z.number().min(1).max(20).default(10).optional().describe("Maximum detections to return"),
+  offset: z.number().min(0).default(0).optional().describe("Number of detections to skip"),
+  include_window: boolFlag().describe("Attach the surrounding messages to each detection (agent output omits them by default)"),
+  window: z.number().min(1).max(5).default(1).optional().describe("Messages on each side with --include-window"),
+  user_id: z.string().min(1).max(256).optional().describe("Scope everything to one end user"),
+  conversation_id: z.string().min(1).max(256).optional().describe("Scope everything to one trace ID")
+});
+var ToolFailuresSchema = z.object({
+  days_back: daysBackFlag(7)
+});
+var ProblemsSchema = z.object({
+  days_back: daysBackFlag(30),
+  limit: z.number().min(1).max(25).default(25).optional().describe("Maximum Problems to return")
+});
+var REMAINDER_FAMILIES = [
+  "tool_failure",
+  "emotion",
+  "laziness",
+  "hallucination",
+  "prm_dip",
+  "custom_signal",
+  "conversation_reader"
+];
+var ProblemsRemainderSchema = z.object({
+  days_back: daysBackFlag(30),
+  limit: z.number().min(1).max(25).default(25).optional().describe("Maximum groups to return"),
+  family: z.enum(REMAINDER_FAMILIES).optional().describe("Only this signal family (frustration is under emotion)"),
+  cursor: z.string().min(1).max(4096).optional().describe("next_cursor from the previous page, verbatim")
+});
+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 ProblemImpactSchema = z.object({
+  node_id: z.string().min(1).max(256).optional().describe("Use case (cluster node) id"),
+  problem_id: z.string().regex(UUID_RE).optional().describe("Problem id (UUID)"),
+  run_id: z.string().min(1).max(256).optional().describe("Analysis run id (for an evidence cursor)"),
+  days_back: z.union([z.literal("all"), z.coerce.number().refine((n) => [1, 3, 7, 30, 90].includes(n), "Use all, 1, 3, 7, 30, or 90 days")]).default(7).describe("Window: all, 1, 3, 7, 30 or 90 days"),
+  mode: z.enum(["metrics", "trend", "evidence", "catalog", "overview", "affected-use-cases", "trace-use-cases"]).default("metrics").describe("Which view to return"),
+  to: z.string().datetime({ precision: 3 }).optional().describe("Window end (ISO timestamp with ms; for an evidence cursor)"),
+  cursor: z.string().min(1).optional().describe("Evidence page cursor from the previous response"),
+  conversation_ids: z.string().transform((value, ctx) => {
+    try {
+      return z.array(z.string().min(1).max(512)).min(1).max(25).parse(JSON.parse(value));
+    } catch {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Use a JSON array of 1–25 conversation IDs" });
+      return z.NEVER;
+    }
+  }).optional().describe("JSON array of 1-25 trace IDs (trace-use-cases mode)")
+}).refine((p) => p.mode !== "trace-use-cases" || p.problem_id && p.conversation_ids, {
+  message: "Trace use cases require --problem-id and --conversation-ids"
+}).refine((p) => p.node_id || p.problem_id || ["catalog", "overview"].includes(p.mode), {
+  message: "Select --node-id or --problem-id, or use --mode=catalog/overview"
+}).refine((p) => !p.cursor || p.mode === "evidence" && p.to && p.run_id, {
+  message: "An evidence cursor requires --mode=evidence, --to, and --run-id from the previous response"
+});
+var PROBLEM_FAMILIES = REMAINDER_FAMILIES;
+var PROBLEM_DOORS = ["rubric_match", "local_causal_chain"];
+var ProblemSchema = z.object({
+  id: z.string().min(1).describe("Problem id"),
+  evidence: boolFlag().describe("Evidence page"),
+  reports: boolFlag().describe("Reports page"),
+  traces: boolFlag().describe("Affected traces page"),
+  conversations: boolFlag().describe("Legacy alias of --traces"),
+  feedback: boolFlag().describe("Feedback history page"),
+  full: boolFlag().describe("Complete dossier in agent output (default is a compact dossier)"),
+  limit: z.number().min(1).max(50).optional().describe("Page size for a sub-resource page"),
+  cursor: z.string().optional().describe("next_cursor from the previous page, verbatim"),
+  family: z.enum(PROBLEM_FAMILIES).optional().describe("With --traces: only this signal family"),
+  door: z.enum(PROBLEM_DOORS).optional().describe("With --traces: only this attribution door")
+});
+var PROBLEM_FEEDBACK_ACTIONS = [
+  "mark_fixed",
+  "dismiss",
+  "flag_attribution",
+  "rename"
+];
+var ProblemFeedbackSchema = z.object({
+  id: z.string().min(1).describe("Problem id (UUID)"),
+  action: z.enum(PROBLEM_FEEDBACK_ACTIONS).describe("What to do with the Problem"),
+  reason: z.string().max(2000).optional().describe("Why (required for flag_attribution; optional for dismiss)"),
+  attribution_id: z.string().max(64).optional().describe("Attribution UUID (required for flag_attribution; from problem --evidence)"),
+  new_name: z.string().max(255).optional().describe("New name (required for rename)"),
+  actor: z.string().max(255).optional().describe("Who is acting (recorded with the feedback)")
+});
+var ProblemLinearFileSchema = z.object({
+  id: z.string().min(1).describe("Problem id (UUID)"),
+  issue: z.string().max(2048).optional().describe("Link this existing Linear issue (ENG-123 or URL) instead of filing"),
+  team_id: z.string().max(255).optional().describe("Linear team to file into (default: the integration's default team)"),
+  title: z.string().optional().describe("Issue title (default: the Problem's name)"),
+  priority: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).max(4).optional()).describe("0 none, 1 urgent, 2 high, 3 medium, 4 low")
+});
+var SignalSchema = z.object({
+  id: z.string().min(1).max(255).describe("Custom signal id"),
+  detections: boolFlag().describe("List recent hits instead of the summary"),
+  days_back: daysBackFlag(),
+  limit: z.number().min(1).max(20).optional().describe("Hits page size (server default 10)"),
+  offset: z.number().min(0).max(1e4).optional().describe("Number of hits to skip")
+});
+var SIGNAL_LABELS = ["fits", "does_not_fit"];
+var SignalLabelSchema = z.object({
+  id: z.string().min(1).max(255).describe("Custom signal id"),
+  conversation_id: z.string().min(1).max(255).describe("Trace ID to label"),
+  label: z.enum(SIGNAL_LABELS).describe("does_not_fit marks a false positive and retracts the hit"),
+  note: z.string().max(2000).optional().describe("Why (recommended for does_not_fit)"),
+  msg_index: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).optional()).describe("Anchor message index (the hit's anchor_msg_index)"),
+  msg_dedup_token: z.string().min(1).max(200).optional().describe("Anchor message token (the hit's anchor_dedup_token)")
+});
+var DETECTION_VERDICTS = ["correct", "false_positive", "clear"];
+var DetectionReviewSchema = z.object({
+  id: z.string().regex(UUID_RE, "Problem id must be a canonical UUID").describe("Problem id (UUID)"),
+  conversation_id: z.string().min(1).max(255).describe("Trace ID the detection is on"),
+  attribution_id: z.string().regex(UUID_RE, "Attribution id must be a UUID").describe("Detection id (from problem --evidence or detection-reviews)"),
+  verdict: z.enum(DETECTION_VERDICTS).describe("clear undoes an earlier review"),
+  note: z.string().max(2000).optional().describe("Why (kept with the review)")
+});
+var FALSE_POSITIVE_KINDS = ["problem", "problem-detection", "quote", "tool", "laziness", "hallucination", "custom-signal"];
+var FalsePositiveSchema = z.object({
+  kind: z.enum(FALSE_POSITIVE_KINDS).describe("What kind of detection is wrong"),
+  target: z.string().min(1).max(255).describe("Problem id (problem, problem-detection), signal id (custom-signal), else the trace ID"),
+  undo: z.boolean().default(false).describe("Remove an earlier mark (every kind except problem)"),
+  reason: z.string().max(2000).optional().describe("Why the detection is wrong"),
+  conversation_id: z.string().min(1).max(255).optional().describe("Trace ID (required for problem-detection and custom-signal)"),
+  attribution_id: z.string().regex(UUID_RE, "Attribution id must be a UUID").optional().describe("Detection UUID (required for problem-detection)"),
+  family: z.string().regex(/^[a-z_]{1,64}$/, "Family must be a lowercase emotion family").optional().describe("Emotion family of the quote (quote kind)"),
+  turn: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).optional()).describe("Turn of the quote (quote kind; from moda emotions)"),
+  quote: z.string().min(1).max(4000).optional().describe("The quoted user text (quote kind)"),
+  tool: z.string().min(1).max(255).optional().describe("Failing tool name (tool kind)"),
+  tool_use_id: z.string().min(1).max(255).optional().describe("Tool call id (tool kind; or pass --msg-index)"),
+  msg_index: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).optional()).describe("Message index of the tool call (tool kind)"),
+  msg_dedup_token: z.string().min(1).max(200).optional().describe("Dedup token of the anchor message")
+}).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",
+  "disapproval",
+  "sadness",
+  "confusion",
+  "anxiety",
+  "trust",
+  "positive"
+];
+var EmotionsSchema = z.object({
+  days_back: daysBackFlag(7),
+  limit: z.number().min(1).max(20).default(10).optional().describe("Maximum detections to return"),
+  offset: z.number().min(0).max(1e4).optional().describe("Number of detections to skip"),
+  family: z.enum(EMOTION_FAMILIES).optional().describe("Only this family in the detections list (summary covers all)"),
+  user_id: z.string().min(1).max(256).optional().describe("Scope everything to one end user"),
+  conversation_id: z.string().min(1).max(256).optional().describe("Scope everything to one trace ID"),
+  include_window: boolFlag().describe("Keep each detection's conversation context (agent output omits it by default)")
+});
+var HallucinationsSchema = z.object({
+  days_back: daysBackFlag(7),
+  limit: z.number().min(1).max(20).default(10).optional().describe("Maximum detections to return"),
+  offset: z.number().min(0).max(1e4).optional().describe("Number of detections to skip"),
+  conversation_id: z.string().max(200).optional().describe("Scope summary and list to one trace ID"),
+  kind: z.enum(["contradicted", "verified"]).optional().describe("Only this kind in the detections list")
+});
+var LAZINESS_FAMILIES = [
+  "omission_comment",
+  "omission_phrase",
+  "stub_body",
+  "refusal_prefix",
+  "deflection",
+  "data_quality_truncation",
+  "promise_no_delivery",
+  "capability_refusal_here",
+  "capability_refusal_verb",
+  "error_admission",
+  "irreversibility",
+  "stall_recheck",
+  "diy_handoff",
+  "tool_selection",
+  "completion",
+  "code_artifact",
+  "repeated_tool_call",
+  "target_overshoot",
+  "data_regression"
+];
+var LazinessSchema = z.object({
+  days_back: daysBackFlag(7),
+  limit: z.number().min(1).max(50).default(10).optional().describe("Maximum detections to return"),
+  offset: z.number().min(0).max(1e4).optional().describe("Number of detections to skip"),
+  conversation_id: z.string().max(200).optional().describe("One trace's detections"),
+  family: z.enum(LAZINESS_FAMILIES).optional().describe("Only this laziness family")
+});
+var StepScoresSchema = z.object({
+  conversation_id: z.string().min(1).describe("Trace ID")
+});
+var TAIL_SIGNALS = ["traces", "conversations", "emotions", "all"];
+var TailSchema = z.object({
+  interval: z.number().min(5).max(3600).default(15).optional().describe("Seconds between polls"),
+  signal: z.enum(TAIL_SIGNALS).default("traces").optional().describe("What to tail (conversations = legacy alias of traces)"),
+  once: boolFlag().describe("Poll once, then exit (baseline page)"),
+  limit: z.number().min(1).max(50).default(20).optional().describe("Page size per poll"),
+  max_events: z.number().min(1).max(1e5).optional().describe("Stop after this many stdout records"),
+  full_scan: boolFlag().describe("Emotions: scan the whole window, not the top-scoring prefix (many more requests)")
+});
+var ToolFailureDetailSchema = z.object({
+  tool_name: z.string().describe("Tool name (from moda tool-failures)"),
+  subtype: z.string().optional().describe("Only this failure subtype"),
+  days_back: daysBackFlag(7),
+  limit: z.number().min(1).max(20).default(5).optional().describe("Maximum examples to return"),
+  offset: z.number().min(0).default(0).optional().describe("Number of examples to skip"),
+  include_window: boolFlag().describe("Embed each example's surrounding messages (on by default)"),
+  compact: boolFlag().describe("Drop each example's embedded messages (same as --include-window=false)"),
+  window: z.number().min(1).max(5).default(1).optional().describe("Messages on each side of the anchor")
+});
+var AuditSchema = z.object({
+  id: z.string().min(1).describe("Trace ID or OTLP trace_id"),
+  kind: z.enum(["auto", "trace", "conversation"]).default("auto").optional().describe("How to read the id (auto tries trace, then conversation)"),
+  include_raw: boolFlag().describe("Include raw span rows"),
+  include_bodies: boolFlag().describe("Keep prompt/response bodies (omitted by default; long strings truncated)"),
+  limit: z.number().min(1).max(1000).default(200).optional().describe("Ingest rows to read; warns when capped"),
+  cursor: z.string().min(1).max(512).optional().describe("next_cursor from the previous page"),
+  ids_from: z.string().min(1).optional().describe("Read several trace ids, one per line, from a file or - for stdin (batch mode, up to 25)")
+});
+var TIME_RANGES = ["all", "1h", "3d", "7d", "24h", "30d", "90d"];
+var SEARCH_MODES = ["keyword", "semantic", "hybrid"];
+var SearchSchema = z.object({
+  q: z.string().min(1).max(500).describe("Search text"),
+  mode: z.enum(SEARCH_MODES).default("hybrid").optional().describe("keyword = exact words, semantic = meaning, hybrid = both"),
+  user_id: z.string().optional().describe("Only messages from this end user"),
+  conversation_id: z.string().min(1).max(256).optional().describe("Search inside one trace only"),
+  time_range: z.enum(TIME_RANGES).default("all").optional().describe("Time window"),
+  since: isoBoundFlag().describe("Absolute UTC start, inclusive (ISO date or datetime); intersected with --time-range"),
+  until: isoBoundFlag().describe("Absolute UTC end, inclusive (ISO date or datetime; a date covers that whole day)"),
+  limit: z.number().min(1).max(100).default(20).optional().describe("Maximum results to return"),
+  include_tool_io: boolFlag().describe("Also search tool inputs and outputs"),
+  offset: z.number().min(0).max(1e4).optional().describe("Skip results (pages the trace-level fallback only)")
+});
+var InvestigateSchema = z.object({
+  days_back: daysBackFlag(7),
+  tool: z.string().optional().describe("Focus on one tool"),
+  trace: z.string().optional().describe("Scope the frustration evidence to one trace ID"),
+  conversation: z.string().optional().describe("Legacy alias of --trace")
+});
+var FailuresSchema = z.object({
+  days_back: daysBackFlag(7),
+  tool: z.string().optional().describe("Focus on one tool")
+});
+var AskSchema = z.object({
+  question: z.string().min(1).describe("The question, in plain language"),
+  days_back: daysBackFlag(7),
+  stream: boolFlag().describe("Stream live progress (default in a terminal; --no-stream turns it off)")
+});
+var TraceSignalsSchema = z.object({
+  conversation_id: z.string().min(1).describe("Trace ID")
+});
+var ProblemLinearSchema = z.object({
+  id: z.string().min(1).describe("Problem id (UUID)")
+});
+var DetectionReviewsSchema = z.object({
+  conversation_id: z.string().min(1).describe("Trace ID"),
+  attribution_id: z.string().regex(UUID_RE).optional().describe("Only this detection (UUID)")
+});
+var FALSE_POSITIVE_LIST_KINDS = ["quote", "tool", "laziness", "hallucination", "custom-signal"];
+var FalsePositivesSchema = z.object({
+  conversation_id: z.string().min(1).optional().describe("List the marks on one trace instead of the whole workspace"),
+  kind: z.enum(FALSE_POSITIVE_LIST_KINDS).optional().describe("Only this kind of mark"),
+  all: boolFlag().describe("Include cleared (undone) marks"),
+  limit: z.number().int().min(1).max(200).optional().describe("Maximum marks to return")
+});
+var SignalsListSchema = z.object({});
+var USER_WINDOWS = ["24h", "7d", "30d", "90d"];
+var USER_COHORTS = ["all", "power_users", "heavy_tool_users", "frustrated", "at_risk", "new_this_week", "silent_sufferers"];
+var USER_SORTS = ["last_seen", "health_score", "conversation_count", "frustration_max"];
+var USER_HEALTH = ["healthy", "at_risk", "frustrated"];
+var UsersSchema = z.object({
+  window: z.enum(USER_WINDOWS).optional().describe("Activity window"),
+  page: z.number().int().min(1).optional().describe("Page number"),
+  page_size: z.number().int().min(1).optional().describe("Users per page"),
+  limit: z.number().int().min(1).optional().describe("Alias of --page-size"),
+  search: z.string().optional().describe("Match user id or name"),
+  cohort: z.enum(USER_COHORTS).optional().describe("Only users in this cohort"),
+  sort: z.enum(USER_SORTS).optional().describe("Sort field"),
+  order: z.enum(["asc", "desc"]).optional().describe("Sort order"),
+  health_status: z.string().optional().describe(`Comma-separated health states (${USER_HEALTH.join(", ")})`),
+  min_health: z.number().int().min(0).max(100).optional().describe("Minimum health score"),
+  max_health: z.number().int().min(0).max(100).optional().describe("Maximum health score"),
+  min_conversations: z.number().int().min(0).optional().describe("Minimum trace count"),
+  min_tool_failures: z.number().int().min(0).optional().describe("Minimum tool failure count"),
+  tenant_id: z.string().optional().describe("Tenant to read; must match the API key's tenant")
+});
+var UserSchema = z.object({
+  user_id: z.string().min(1).describe("End user id"),
+  window: z.enum(USER_WINDOWS).optional().describe("Activity window"),
+  activity_cursor: z.string().optional().describe("Activity page cursor from the previous response"),
+  tenant_id: z.string().optional().describe("Tenant to read; must match the API key's tenant")
+});
+var ProblemReopenSchema = z.object({
+  id: z.string().regex(UUID_RE).describe("Problem id (UUID)"),
+  reason: z.string().max(500).optional().describe("Why it is being reopened"),
+  dry_run: boolFlag().describe("Print the request and send nothing")
+});
+
+// ../../packages/database/src/agent-feedback.ts
+var FEEDBACK_CATEGORIES = [
+  "bad_cluster_label",
+  "mismatched_frustration",
+  "missing_data",
+  "noisy_data",
+  "wrong_tool_failure",
+  "incorrect_loop",
+  "api_quirk",
+  "false_positive_attribution",
+  "misrouted_fix",
+  "harness_bug",
+  "other"
+];
+var FEEDBACK_SEVERITIES = ["info", "low", "medium", "high"];
+var DEFAULT_FEEDBACK_CATEGORY = "other";
+var RAW_FEEDBACK_CATEGORY_MAX = 64;
+function isFeedbackCategory(value) {
+  return typeof value === "string" && FEEDBACK_CATEGORIES.includes(value);
+}
+function normalizeFeedbackCategory(value) {
+  if (value === undefined || value === null || value === "")
+    return { category: DEFAULT_FEEDBACK_CATEGORY };
+  if (isFeedbackCategory(value))
+    return { category: value };
+  const raw = String(value).trim().slice(0, RAW_FEEDBACK_CATEGORY_MAX);
+  return raw ? { category: DEFAULT_FEEDBACK_CATEGORY, raw_category: raw } : { category: DEFAULT_FEEDBACK_CATEGORY };
+}
+
+// src/feedback.ts
+import { z as z2 } from "zod";
+var FeedbackSchema = z2.object({
+  note: z2.string().min(1).max(4000).describe("What is wrong or missing"),
+  category: z2.enum(FEEDBACK_CATEGORIES).default("other").describe("What kind of problem; an unknown value is sent as other"),
+  severity: z2.enum(FEEDBACK_SEVERITIES).default("low").describe("How bad it is"),
+  conversation_id: z2.string().optional().describe("Attach the trace ID you were looking at"),
+  cluster_id: z2.string().optional().describe("Attach a cluster node id"),
+  tool_name: z2.string().optional().describe("Attach a tool name"),
+  run_id: z2.string().optional().describe("Attach a run id")
+});
+var FEEDBACK_FLAGS = Object.keys(FeedbackSchema.shape).map((key) => key.replace(/_/g, "-"));
+var FEEDBACK_USAGE = `Usage: moda feedback "<note>" [--category=${FEEDBACK_CATEGORIES.join("|")}] ` + `[--severity=${FEEDBACK_SEVERITIES.join("|")}] [--conversation-id=ID] [--cluster-id=ID] ` + "[--tool-name=NAME] [--run-id=ID] [--<name>-id=ID]";
+var NOTE_MAX = 4000;
+var REF_VALUE_MAX = 256;
+var REF_FLAG_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*-(?:id|ids|index|token)$/;
+var REF_FLAG_WORDS = new Set(["turn", "tool", "family", "kind"]);
+function isFeedbackRefFlag(flag) {
+  return REF_FLAG_PATTERN.test(flag) || REF_FLAG_WORDS.has(flag);
+}
+function buildFeedbackRequest(positionals, flags, bareFlags) {
+  const isBare = (flag) => bareFlags ? bareFlags.includes(flag) : flags[flag] === "true";
+  const flagNote = flags.note !== undefined && !isBare("note") ? flags.note.trim() : "";
+  const note = [positionals.join(" ").trim(), flagNote].filter(Boolean).join(`
+`);
+  if (note === "")
+    throw new CliInputError("<note> is required", FEEDBACK_USAGE);
+  if (note.length > NOTE_MAX) {
+    throw new CliInputError(`<note> is ${note.length} characters; the limit is ${NOTE_MAX}.`, FEEDBACK_USAGE);
+  }
+  const severity = flags.severity ?? "low";
+  if (!FEEDBACK_SEVERITIES.includes(severity)) {
+    throw new CliInputError(`Invalid --severity '${severity}'. Valid severities: ${FEEDBACK_SEVERITIES.join(", ")}.`, FEEDBACK_USAGE);
+  }
+  const refs = {};
+  for (const [flag, value] of Object.entries(flags)) {
+    if (flag === "category" || flag === "severity" || flag === "note")
+      continue;
+    if (!FEEDBACK_FLAGS.includes(flag) && !isFeedbackRefFlag(flag))
+      continue;
+    const trimmed = value.trim();
+    if (value === "true" || trimmed === "") {
+      throw new CliInputError(`--${flag} needs a value, e.g. --${flag}=<id>.`, FEEDBACK_USAGE);
+    }
+    if (trimmed.length > REF_VALUE_MAX) {
+      throw new CliInputError(`--${flag} is ${trimmed.length} characters; the limit is ${REF_VALUE_MAX}.`, FEEDBACK_USAGE);
+    }
+    refs[flag.replace(/-/g, "_")] = trimmed;
+  }
+  const warnings = [];
+  const { category, raw_category: rawCategory } = normalizeFeedbackCategory(flags.category);
+  if (rawCategory !== undefined) {
+    refs.raw_category = rawCategory;
+    warnings.push(`Unknown category '${rawCategory}': sent as 'other' with refs.raw_category. ` + `Valid categories: ${FEEDBACK_CATEGORIES.join(", ")}.`);
+  }
+  const hint = dedicatedCommandHint(category, rawCategory);
+  if (hint)
+    warnings.push(hint);
+  return { category, severity, note, refs, warnings };
+}
+var MISROUTE_CATEGORIES = new Set(["false_positive_attribution", "misrouted_fix"]);
+var MISROUTE_WORDS = /attribut|misrout|false[\s_-]?positive|wrong[\s_-]?(?:problem|fix)/i;
+function dedicatedCommandHint(category, rawCategory) {
+  if (!MISROUTE_CATEGORIES.has(category) && !(rawCategory && MISROUTE_WORDS.test(rawCategory)))
+    return;
+  return "Feedback is read by the Moda team but does not change the problem. To act on it directly, use " + "`moda problem-feedback <problem_id> --action=flag_attribution --attribution-id=<uuid> --reason=TEXT` (a trace wrongly " + "attributed to a problem), `moda false-positive <kind> <target> --reason=TEXT` (a detection that should not " + "have fired), or `moda fix dismiss <fix_id> --reason=TEXT` (a fix aimed at the wrong problem).";
+}
+
+// src/command-flags.ts
+import { z as z3 } from "zod";
+var TRACE_ID = { name: "conversation_id", key: "conversation_id", required: true };
+var PROBLEM_ID = { name: "problem_id", key: "id", required: true };
+var COMMAND_FLAG_SPECS = {
+  overview: { schema: OverviewSchema, extra: z3.object({ raw: z3.boolean().optional().describe("Print the raw briefing data") }) },
+  investigate: { schema: InvestigateSchema, handParsed: true },
+  failures: { schema: FailuresSchema, handParsed: true },
+  ask: { schema: AskSchema, handParsed: true, positionals: [{ name: "question", key: "question", required: true }] },
+  clusters: { schema: ClustersSchema },
+  "cluster-traces": { schema: ClusterConversationsSchema, positionals: [{ name: "node_id", key: "node_id", required: true }] },
+  traces: { schema: ConversationsSchema },
+  search: { schema: SearchSchema, positionals: [{ name: "query", key: "q", required: true }] },
+  "world-state": { schema: WorldStateSchema, positionals: [TRACE_ID] },
+  context: {
+    schema: ContextSchema,
+    positionals: [{ ...TRACE_ID, alsoFlag: true }],
+    flagAliases: { "message-index": "msg-index" }
+  },
+  audit: { schema: AuditSchema, positionals: [{ name: "conversation_id|trace_id", key: "id", required: true }] },
+  frustrations: { schema: FrustrationsSchema },
+  "tool-failures": { schema: ToolFailuresSchema },
+  "tool-failure-detail": { schema: ToolFailureDetailSchema, positionals: [{ name: "tool_name", key: "tool_name", required: true }] },
+  problems: {
+    schema: ProblemsSchema,
+    subcommands: { remainder: { schema: ProblemsRemainderSchema } }
+  },
+  "problem-impact": { schema: ProblemImpactSchema, handParsed: true },
+  problem: { schema: ProblemSchema, positionals: [PROBLEM_ID] },
+  "problem-feedback": { schema: ProblemFeedbackSchema, handParsed: true, positionals: [PROBLEM_ID] },
+  "problem-reopen": { schema: ProblemReopenSchema, handParsed: true, positionals: [PROBLEM_ID] },
+  "problem-linear": { schema: ProblemLinearSchema, handParsed: true, positionals: [PROBLEM_ID] },
+  "problem-linear-file": { schema: ProblemLinearFileSchema, handParsed: true, positionals: [PROBLEM_ID] },
+  "detection-reviews": { schema: DetectionReviewsSchema, handParsed: true, positionals: [TRACE_ID] },
+  "detection-review": { schema: DetectionReviewSchema, handParsed: true, positionals: [PROBLEM_ID] },
+  "false-positive": {
+    schema: FalsePositiveSchema,
+    handParsed: true,
+    positionals: [
+      { name: "kind", key: "kind", required: true },
+      { name: "target", key: "target", required: true }
+    ]
+  },
+  "false-positives": {
+    schema: FalsePositivesSchema,
+    handParsed: true,
+    positionals: [{ name: "conversation_id", key: "conversation_id", required: false }]
+  },
+  signals: { schema: SignalsListSchema, handParsed: true },
+  signal: { schema: SignalSchema, positionals: [{ name: "signal_id", key: "id", required: true }] },
+  "trace-signals": { schema: TraceSignalsSchema, handParsed: true, positionals: [TRACE_ID] },
+  "signal-label": { schema: SignalLabelSchema, handParsed: true, positionals: [{ name: "signal_id", key: "id", required: true }] },
+  emotions: { schema: EmotionsSchema },
+  laziness: { schema: LazinessSchema },
+  hallucinations: { schema: HallucinationsSchema },
+  "step-scores": { schema: StepScoresSchema, handParsed: true, positionals: [TRACE_ID] },
+  tail: { schema: TailSchema },
+  feedback: {
+    schema: FeedbackSchema,
+    handParsed: true,
+    idRefFlags: true,
+    positionals: [{ name: "note", key: "note", required: true, variadic: true, alsoFlag: true }]
+  },
+  users: { schema: UsersSchema, handParsed: true },
+  user: { schema: UserSchema, handParsed: true, positionals: [{ name: "user_id", key: "user_id", required: true }] }
+};
+function flagSpecFor(command) {
+  return Object.hasOwn(COMMAND_FLAG_SPECS, command) ? COMMAND_FLAG_SPECS[command] : undefined;
+}
+function kebabFlag(key) {
+  return `--${key.replace(/_/g, "-")}`;
+}
+function schemaShape(schema) {
+  let current = schema;
+  while (current instanceof z3.ZodEffects)
+    current = current.innerType();
+  return current instanceof z3.ZodObject ? current.shape : {};
+}
+function scalarDefault(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : undefined;
+}
+function literalValues(schema) {
+  if (schema instanceof z3.ZodEnum)
+    return [...schema.options];
+  if (schema instanceof z3.ZodLiteral)
+    return [String(schema.value)];
+  return;
+}
+function describeField(field) {
+  let current = field;
+  let description;
+  let optional = false;
+  let defaultValue;
+  for (;; ) {
+    description ??= current.description;
+    if (current instanceof z3.ZodOptional || current instanceof z3.ZodNullable) {
+      optional = true;
+      current = current.unwrap();
+    } else if (current instanceof z3.ZodDefault) {
+      optional = true;
+      defaultValue ??= scalarDefault(current._def.defaultValue());
+      current = current._def.innerType;
+    } else if (current instanceof z3.ZodEffects) {
+      current = current.innerType();
+    } else if (current instanceof z3.ZodPipeline) {
+      current = current._def.in;
+    } else {
+      break;
+    }
+  }
+  const info = { type: "string", optional, ...defaultValue !== undefined ? { default: defaultValue } : {} };
+  if (description)
+    info.description = description;
+  const values = literalValues(current);
+  if (values) {
+    info.type = "enum";
+    info.enum = values;
+  } else if (current instanceof z3.ZodUnion) {
+    const options = current.options.map((option) => literalValues(option));
+    if (options.every((option) => option !== undefined)) {
+      info.type = "enum";
+      info.enum = options.flat();
+    }
+  } else if (current instanceof z3.ZodBoolean) {
+    info.type = "boolean";
+  } else if (current instanceof z3.ZodNumber) {
+    info.type = current.isInt ? "integer" : "number";
+    for (const check of current._def.checks) {
+      if (check.kind === "min")
+        info.min = check.inclusive ? check.value : check.value + (info.type === "integer" ? 1 : 0);
+      if (check.kind === "max")
+        info.max = check.inclusive ? check.value : check.value - (info.type === "integer" ? 1 : 0);
+    }
+  }
+  return info;
+}
+function positionalKeys(spec) {
+  return new Set((spec.positionals ?? []).filter((p) => p.key && !p.alsoFlag).map((p) => p.key));
+}
+function specFlagKeys(spec) {
+  const skip = positionalKeys(spec);
+  return [
+    ...Object.keys(schemaShape(spec.schema)).filter((key) => !skip.has(key)),
+    ...Object.keys(spec.extra?.shape ?? {})
+  ];
+}
+function specFlagNames(spec) {
+  return [
+    ...specFlagKeys(spec).map((key) => key.replace(/_/g, "-")),
+    ...Object.keys(spec.flagAliases ?? {})
+  ];
+}
+function describeSpecFlags(spec) {
+  const shape = { ...schemaShape(spec.schema), ...spec.extra?.shape ?? {} };
+  const flagPositionals = new Map((spec.positionals ?? []).filter((p) => p.alsoFlag && p.key).map((p) => [p.key, p]));
+  const flags = specFlagKeys(spec).map((key) => {
+    const info = describeField(shape[key]);
+    const positional = flagPositionals.get(key);
+    if (positional)
+      info.description = `Same as the <${positional.name}> argument`;
+    const descriptor = { name: kebabFlag(key), type: info.type, required: !info.optional && !positional };
+    if (info.enum)
+      descriptor.enum = info.enum;
+    if (info.min !== undefined)
+      descriptor.min = info.min;
+    if (info.max !== undefined)
+      descriptor.max = info.max;
+    if (info.default !== undefined)
+      descriptor.default = info.default;
+    if (info.description)
+      descriptor.description = info.description;
+    return descriptor;
+  });
+  for (const [alias, canonical] of Object.entries(spec.flagAliases ?? {})) {
+    const target = flags.find((flag) => flag.name === `--${canonical}`);
+    flags.push({
+      ...target ?? { type: "string" },
+      name: `--${alias}`,
+      required: false,
+      description: `Alias of --${canonical}`,
+      alias_of: `--${canonical}`
+    });
+  }
+  return flags;
+}
+function describeSpecPositionals(spec) {
+  const shape = schemaShape(spec.schema);
+  return (spec.positionals ?? []).map((positional) => {
+    const field = positional.key ? shape[positional.key] : undefined;
+    const info = field ? describeField(field) : undefined;
+    const description = positional.description ?? info?.description;
+    return {
+      name: positional.name,
+      required: positional.required,
+      ...info?.enum ? { enum: info.enum } : {},
+      ...description ? { description } : {},
+      ...positional.variadic ? { variadic: true } : {},
+      ...positional.alsoFlag && positional.key ? { flag: kebabFlag(positional.key) } : {}
+    };
+  });
+}
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1;i <= a.length; i++) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1;j <= b.length; j++) {
+      const current = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = current;
+    }
+  }
+  return row[b.length];
+}
+function closestMatches(input, candidates, max = 3) {
+  const normalize = (value) => value.toLowerCase().replace(/_/g, "-");
+  const target = normalize(input);
+  if (!target)
+    return [];
+  const limit = Math.min(3, Math.max(1, Math.floor(target.length / 3)));
+  const scored = [];
+  for (const candidate of new Set(candidates)) {
+    const normalized = normalize(candidate);
+    if (normalized === target)
+      continue;
+    const distance = editDistance(target, normalized);
+    if (distance <= limit) {
+      scored.push({ candidate, score: distance });
+    } else if (target.length >= 3 && (normalized.startsWith(target) || target.startsWith(normalized))) {
+      scored.push({ candidate, score: limit + 1 });
+    }
+  }
+  return scored.sort((left, right) => left.score - right.score || left.candidate.localeCompare(right.candidate)).slice(0, max).map(({ candidate }) => candidate);
+}
+function placeholder(flag) {
+  if (flag.type === "boolean")
+    return "";
+  if (flag.type === "enum" && flag.enum) {
+    const joined = flag.enum.join("|");
+    return joined.length <= 32 ? `=${joined}` : "=<value>";
+  }
+  if (flag.type === "integer" || flag.type === "number")
+    return "=N";
+  if (/(^--|-)(cursor|token)$/.test(flag.name))
+    return "=TOKEN";
+  return /-ids?$/.test(flag.name) ? "=ID" : "=TEXT";
+}
+function rangeText(flag) {
+  if (flag.min !== undefined && flag.max !== undefined)
+    return `${flag.min}-${flag.max}`;
+  if (flag.min !== undefined)
+    return `min ${flag.min}`;
+  if (flag.max !== undefined)
+    return `max ${flag.max}`;
+  return;
+}
+function flagDetail(flag) {
+  const facts = [];
+  if (flag.required)
+    facts.push("required");
+  if (flag.type === "enum" && flag.enum && flag.enum.join("|").length > 32)
+    facts.push(`one of ${flag.enum.join(", ")}`);
+  const range = rangeText(flag);
+  if (range)
+    facts.push(range);
+  if (flag.default !== undefined && flag.type !== "boolean")
+    facts.push(`default ${flag.default}`);
+  const description = flag.description ?? "";
+  if (facts.length === 0)
+    return description;
+  return description ? `${description} [${facts.join("; ")}]` : `[${facts.join("; ")}]`;
+}
+function usageLine(command, spec) {
+  const positionals = (spec.positionals ?? []).map((positional) => {
+    const word = `<${positional.name}>${positional.variadic ? "..." : ""}`;
+    return positional.required ? word : `[${word}]`;
+  });
+  const hasFlags = specFlagKeys(spec).length > 0;
+  return ["moda", command, ...positionals, ...hasFlags ? ["[flags]"] : []].join(" ");
+}
+function table(rows) {
+  const width = Math.min(34, Math.max(...rows.map(([left]) => left.length)));
+  return rows.map(([left, right]) => {
+    if (!right)
+      return `  ${left}`;
+    return left.length > width ? `  ${left}
+  ${" ".repeat(width)}  ${right}` : `  ${left.padEnd(width)}  ${right}`;
+  });
+}
+function renderFlagHelp(command, spec) {
+  const lines = [`Usage: ${usageLine(command, spec)}`];
+  const positionals = describeSpecPositionals(spec);
+  if (positionals.length > 0) {
+    lines.push("", "Arguments:");
+    lines.push(...table(positionals.map((positional) => {
+      const notes = [
+        positional.required ? "required" : "optional",
+        ...positional.enum ? [`one of ${positional.enum.join(", ")}`] : [],
+        ...positional.flag ? [`or ${positional.flag}=...`] : []
+      ];
+      return [`<${positional.name}>`, `${positional.description ?? ""} [${notes.join("; ")}]`.trim()];
+    })));
+  }
+  const flags = describeSpecFlags(spec);
+  lines.push("", "Flags:");
+  if (flags.length === 0) {
+    lines.push("  (none besides the output flags below)");
+  } else {
+    lines.push(...table(flags.map((flag) => [`${flag.name}${placeholder(flag)}`, flagDetail(flag)])));
+  }
+  for (const [name, subcommand] of Object.entries(spec.subcommands ?? {})) {
+    lines.push("", `Flags for 'moda ${command} ${name}':`);
+    lines.push(...table(describeSpecFlags(subcommand).map((flag) => [`${flag.name}${placeholder(flag)}`, flagDetail(flag)])));
+  }
+  return lines;
+}
+function subcommandHelpFlags(spec) {
+  return describeSpecFlags(spec).map((flag) => ({ name: `${flag.name}${placeholder(flag)}`, description: flagDetail(flag) }));
+}
+function manifestFlagFields(spec) {
+  const subcommands = Object.entries(spec.subcommands ?? {});
+  return {
+    positionals: describeSpecPositionals(spec),
+    flags: describeSpecFlags(spec),
+    ...subcommands.length > 0 ? { subcommand_flags: Object.fromEntries(subcommands.map(([name, sub]) => [name, describeSpecFlags(sub)])) } : {}
+  };
+}
+
+// src/parity-commands.ts
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+var UUID_RE2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var WINDOWS = USER_WINDOWS;
+function profileOptions(context) {
+  return { profile: context.profile, env: context.env };
+}
+function requireKey(context) {
+  if (!resolveApiKey(profileOptions(context))) {
+    throw new CliInputError(`No Moda API key found for moda ${context.command}.`, "Set MODA_API_KEY, run `moda auth login --api-key`, or select a profile with an API key.");
+  }
+}
+function requireTenant(context) {
+  const key = resolveApiKey(profileOptions(context));
+  const keyTenant = key ? embeddedTenantIdFromApiKey(key) : undefined;
+  const flagTenant = context.flags["tenant-id"];
+  if (flagTenant && keyTenant && flagTenant !== keyTenant) {
+    throw new CliInputError(`--tenant-id=${flagTenant} does not match this API key's tenant (${keyTenant}), so nothing was sent.`, "Drop --tenant-id (the key names its tenant) or use a key for that tenant.");
+  }
+  const tenantId = flagTenant || resolveApiTenantId(profileOptions(context));
+  if (!tenantId) {
+    throw new CliInputError("Could not determine the tenant.", "Use a signed API key (it names its tenant), set MODA_TENANT_ID, or pass --tenant-id=<id>.");
+  }
+  if (isPlatformApiKey(key))
+    setPlatformTenantOverride(tenantId);
+  return tenantId;
+}
+function assertFlags(command, flags, allowed) {
+  if (command.startsWith("signals "))
+    allowed = [...allowed, "tenant-id"];
+  const globals = [
+    "agent",
+    "json",
+    "human",
+    "prose",
+    "quiet",
+    "verbose",
+    "yes",
+    "profile",
+    "progress",
+    "format",
+    "no-telemetry",
+    "no-update-check",
+    "help",
+    "version",
+    "json-schemas",
+    "stream",
+    "no-stream",
+    "tui",
+    "no-tui"
+  ];
+  const known = new Set([...allowed, ...globals]);
+  const unknown = Object.keys(flags).filter((flag) => !known.has(flag));
+  if (unknown.includes("dry-run")) {
+    throw new CliInputError(`'moda ${command}' has no dry-run mode, so nothing was sent.`, "Remove --dry-run to run it for real.");
+  }
+  if (unknown.length > 0) {
+    const valid = allowed.map((flag) => `--${flag}`);
+    const didYouMean = [...new Set(unknown.flatMap((flag) => closestMatches(`--${flag}`, valid, 1)))];
+    const helpCommand = `moda ${command} --help`;
+    throw new CliInputError(`Unknown flag${unknown.length > 1 ? "s" : ""} ${unknown.map((flag) => `--${flag}`).join(", ")} for 'moda ${command}'.` + (didYouMean.length > 0 ? ` Did you mean ${didYouMean.join(", ")}?` : ""), `Valid flags: ${valid.join(", ") || "(none)"}. Run '${helpCommand}'.`, `unknown_flag:${unknown[0]}`, {
+      field: `--${unknown[0]}`,
+      allowed: valid,
+      ...didYouMean.length > 0 ? { didYouMean } : {},
+      suggestedCommands: [helpCommand]
+    });
+  }
+}
+function assertPositionals(command, positionals, max, usage) {
+  if (positionals.length > max) {
+    throw new CliInputError(`Unexpected argument${positionals.length - max > 1 ? "s" : ""} '${positionals.slice(max).join(" ")}' for 'moda ${command}', so nothing was sent.`, `Usage: ${usage}`);
+  }
+}
+function oneOf(name, value, allowed) {
+  if (value === undefined)
+    return;
+  if (!allowed.includes(value)) {
+    throw new CliInputError(`--${name} must be one of ${allowed.join(", ")} (got '${value}').`);
+  }
+  return value;
+}
+function csv(value) {
+  if (value === undefined)
+    return;
+  const items = value.split(",").map((item) => item.trim()).filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+function readBodyFile(flags, cwd) {
+  if (!flags.file)
+    return {};
+  if (flags.file === "true")
+    throw new CliInputError("Missing path for --file.");
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(resolve(cwd, flags.file), "utf8"));
+  } catch (error) {
+    throw new CliInputError(`Could not read --file ${flags.file}: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new CliInputError("--file must contain a JSON object (the request body).");
+  }
+  return parsed;
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== undefined));
+}
+var LLM_WRITE_TIMEOUT_MS = 180000;
+async function send(context, plane, method, endpoint, body, options = {}) {
+  const init = { method, ...body !== undefined ? { body: JSON.stringify(body) } : {} };
+  if (method !== "GET" && context.dryRun) {
+    context.output.writeData({
+      dryRun: true,
+      planned: { method, endpoint: plane === "data" ? `/api/v1/data${endpoint}` : `/api${endpoint}`, ...body !== undefined ? { body } : {} }
+    }, { summary: { text: `Dry run: would ${method} ${endpoint}. Nothing was sent.`, confidence: "high" } });
+    return;
+  }
+  const requestOptions = method === "GET" ? {} : { retries: 0, ...options.slow ? { timeoutMs: LLM_WRITE_TIMEOUT_MS } : {} };
+  const data = plane === "data" ? await callDataAPI(endpoint, init, requestOptions) : await callControlAPI(endpoint, init, profileOptions(context), requestOptions);
+  context.output.writeData(data ?? { ok: true });
+}
+var HEALTH = USER_HEALTH;
+async function runUsersCommand(context) {
+  const flags = context.flags;
+  assertFlags("users", flags, specFlagNames(COMMAND_FLAG_SPECS.users));
+  if (context.positionals.length > 0) {
+    throw new CliInputError(`'moda users' takes no arguments. For one user use 'moda user <user_id>'.`);
+  }
+  if (flags.limit !== undefined && flags["page-size"] !== undefined && flags.limit !== flags["page-size"]) {
+    throw new CliInputError(`Got --limit=${flags.limit} and --page-size=${flags["page-size"]}; they are the same flag for 'moda users', so nothing was sent.`, "Pass only one of --limit / --page-size.", "flag_conflict");
+  }
+  requireKey(context);
+  const tenantId = requireTenant(context);
+  const query = new URLSearchParams(compact({
+    window: oneOf("window", flags.window, WINDOWS),
+    page: flags.page,
+    pageSize: flags["page-size"] ?? flags.limit,
+    search: flags.search,
+    cohort: oneOf("cohort", flags.cohort, USER_COHORTS),
+    sortBy: oneOf("sort", flags.sort, USER_SORTS),
+    sortOrder: oneOf("order", flags.order, ["asc", "desc"]),
+    healthStatus: csv(flags["health-status"])?.map((value) => oneOf("health-status", value, HEALTH)).join(","),
+    minHealthScore: flags["min-health"],
+    maxHealthScore: flags["max-health"],
+    minConversations: flags["min-conversations"],
+    minToolFailures: flags["min-tool-failures"]
+  }));
+  const suffix = query.toString() ? `?${query.toString()}` : "";
+  await send(context, "control", "GET", `/tenants/${encodeURIComponent(tenantId)}/users${suffix}`);
+  return { exitCode: 0 };
+}
+async function runUserCommand(context) {
+  const flags = context.flags;
+  assertFlags("user", flags, specFlagNames(COMMAND_FLAG_SPECS.user));
+  assertPositionals("user", context.positionals, 1, "moda user <user_id> [--window=24h|7d|30d|90d]");
+  const userId = context.positionals[0];
+  if (!userId)
+    throw new CliInputError("<user_id> is required.", "Usage: moda user <user_id> [--window=24h|7d|30d|90d]");
+  requireKey(context);
+  const tenantId = requireTenant(context);
+  const query = new URLSearchParams(compact({
+    window: oneOf("window", flags.window, WINDOWS),
+    activityCursor: flags["activity-cursor"]
+  }));
+  const suffix = query.toString() ? `?${query.toString()}` : "";
+  await send(context, "control", "GET", `/tenants/${encodeURIComponent(tenantId)}/users/${encodeURIComponent(userId)}${suffix}`);
+  return { exitCode: 0 };
+}
+async function runProblemReopenCommand(context) {
+  assertFlags("problem-reopen", context.flags, specFlagNames(COMMAND_FLAG_SPECS["problem-reopen"]));
+  assertPositionals("problem-reopen", context.positionals, 1, "moda problem-reopen <problem_id> [--reason=TEXT]");
+  const problemId = context.positionals[0];
+  const usage = "Usage: moda problem-reopen <problem_id> [--reason=TEXT]";
+  if (!problemId || !UUID_RE2.test(problemId))
+    throw new CliInputError("<problem_id> (UUID) is required.", usage);
+  const reason = context.flags.reason;
+  if (reason !== undefined && reason.length > 500)
+    throw new CliInputError("--reason must be 500 characters or fewer.");
+  requireKey(context);
+  await send(context, "data", "POST", `/problems/${problemId}/reopen`, compact({ reason }));
+  return { exitCode: 0 };
+}
+var SIGNAL_FIELD_FLAGS = [
+  "name",
+  "description",
+  "pass-criteria",
+  "fail-criteria",
+  "polarity",
+  "locus",
+  "tool-names",
+  "keyword-hints",
+  "use-case-id",
+  "message-types",
+  "note",
+  "file"
+];
+function signalBody(flags, cwd) {
+  const fromFile = readBodyFile(flags, cwd);
+  const scope = compact({
+    toolNames: csv(flags["tool-names"]),
+    keywordHints: csv(flags["keyword-hints"]),
+    useCaseId: flags["use-case-id"],
+    messageTypes: csv(flags["message-types"])
+  });
+  return {
+    ...fromFile,
+    ...compact({
+      name: flags.name,
+      description: flags.description,
+      passCriteria: flags["pass-criteria"],
+      failCriteria: flags["fail-criteria"],
+      polarity: oneOf("polarity", flags.polarity, ["violation", "expectation"]),
+      locus: oneOf("locus", flags.locus, ["agent", "tool_output", "user_input"]),
+      note: flags.note
+    }),
+    ...Object.keys(scope).length > 0 ? { scope: { ...fromFile.scope ?? {}, ...scope } } : {}
+  };
+}
+var SIGNAL_USAGE = [
+  "moda signals                                   list custom signals",
+  'moda signals draft --note="…"                  AI-draft criteria from a description',
+  "moda signals create --name --description --pass-criteria --fail-criteria [--polarity --locus --tool-names=a,b] [--file=body.json]",
+  "moda signals update <id> [same flags]           edit a signal",
+  "moda signals activate|pause|delete <id>          (delete: drafts only; archive is dashboard-only)",
+  "moda signals examples <id> add|update|remove --conversation-id=ID [--label=fits|does_not_fit --note --msg-index]",
+  'moda signals refine <id> --request="…"          propose a criteria edit',
+  "moda signals revise <id> --conversation-ids=a,b re-derive criteria from labelled traces",
+  "moda signals proposals <id> | accept <id> <proposal_id> | reject <id> <proposal_id>",
+  "moda signals search <id> [--mode=wizard|full] | search-status <id> <search_id> | search-stop <id> <search_id>",
+  "moda signals preview --file=detector.json [--conversation-ids=a,b --max-examples=N]",
+  "All write subcommands accept --dry-run (prints the request, sends nothing)."
+].join(`
+  `);
+async function runSignalsManagementCommand(sub, context) {
+  const flags = context.flags;
+  const args = context.positionals.slice(1);
+  const arity = {
+    draft: 0,
+    create: 0,
+    preview: 0,
+    update: 1,
+    activate: 1,
+    pause: 1,
+    delete: 1,
+    examples: 2,
+    refine: 1,
+    revise: 1,
+    proposals: 1,
+    accept: 2,
+    reject: 2,
+    search: 1,
+    "search-status": 2,
+    "search-stop": 2
+  };
+  if (sub in arity)
+    assertPositionals(`signals ${sub}`, args, arity[sub], SIGNAL_USAGE.split(`
+`)[0]);
+  const base = () => `/tenants/${encodeURIComponent(requireTenant(context))}/custom-signals`;
+  const id = (index = 0, what = "a signal id") => {
+    const value = args[index];
+    if (!value)
+      throw new CliInputError(`moda signals ${sub} needs ${what}.`, `Usage:
+  ${SIGNAL_USAGE}`);
+    return encodeURIComponent(value);
+  };
+  const start = () => requireKey(context);
+  switch (sub) {
+    case "draft": {
+      assertFlags("signals draft", flags, ["note", "file", "dry-run"]);
+      const body = { ...readBodyFile(flags, context.cwd), ...compact({ note: flags.note }) };
+      if (!body.note)
+        throw new CliInputError("--note is required (describe what the signal should catch).");
+      start();
+      await send(context, "control", "POST", `${base()}/draft`, body, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "create": {
+      assertFlags("signals create", flags, [...SIGNAL_FIELD_FLAGS, "dry-run"]);
+      const body = signalBody(flags, context.cwd);
+      const missing = ["name", "description", "passCriteria", "failCriteria"].filter((field) => !body[field]);
+      if (missing.length > 0) {
+        throw new CliInputError(`Missing ${missing.join(", ")} for signals create.`, 'Pass --name --description --pass-criteria --fail-criteria, or a --file with those fields. Tip: `moda signals draft --note="…"` drafts them.');
+      }
+      start();
+      await send(context, "control", "POST", base(), body);
+      return { exitCode: 0 };
+    }
+    case "update": {
+      assertFlags("signals update", flags, [...SIGNAL_FIELD_FLAGS, "dry-run"]);
+      const signalId = id();
+      const body = signalBody(flags, context.cwd);
+      if (Object.keys(body).length === 0)
+        throw new CliInputError("Nothing to update: pass at least one field flag or --file.");
+      start();
+      await send(context, "control", "PATCH", `${base()}/${signalId}`, body);
+      return { exitCode: 0 };
+    }
+    case "activate":
+    case "pause": {
+      assertFlags(`signals ${sub}`, flags, ["dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/${sub}`);
+      return { exitCode: 0 };
+    }
+    case "delete": {
+      assertFlags("signals delete", flags, ["dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "DELETE", `${base()}/${signalId}`);
+      return { exitCode: 0 };
+    }
+    case "examples": {
+      const signalId = id();
+      const action = args[1];
+      const conversationId = flags["conversation-id"];
+      if (!action || !["add", "update", "remove"].includes(action)) {
+        throw new CliInputError("Usage: moda signals examples <id> add|update|remove --conversation-id=ID …");
+      }
+      if (!conversationId)
+        throw new CliInputError("--conversation-id is required.");
+      if (action === "add") {
+        assertFlags("signals examples add", flags, ["conversation-id", "label", "note", "msg-index", "msg-dedup-token", "criteria", "verdict", "dry-run"]);
+        const label = oneOf("label", flags.label, ["fits", "does_not_fit"]);
+        if (!label)
+          throw new CliInputError("--label=fits|does_not_fit is required.");
+        start();
+        await send(context, "control", "POST", `${base()}/${signalId}/examples`, compact({
+          conversationId,
+          label,
+          source: "api",
+          note: flags.note,
+          msgIndex: flags["msg-index"] !== undefined ? Number(flags["msg-index"]) : undefined,
+          msgDedupToken: flags["msg-dedup-token"],
+          criteria: oneOf("criteria", flags.criteria, ["pass", "fail"]),
+          verdict: oneOf("verdict", flags.verdict, ["accept", "reject"])
+        }));
+      } else if (action === "update") {
+        assertFlags("signals examples update", flags, ["conversation-id", "label", "note", "blurb", "dry-run"]);
+        const body = compact({ label: oneOf("label", flags.label, ["fits", "does_not_fit"]), note: flags.note, blurb: flags.blurb });
+        if (Object.keys(body).length === 0)
+          throw new CliInputError("Nothing to update: pass --label, --note, or --blurb.");
+        start();
+        await send(context, "control", "PATCH", `${base()}/${signalId}/examples/${encodeURIComponent(conversationId)}`, body);
+      } else {
+        assertFlags("signals examples remove", flags, ["conversation-id", "dry-run"]);
+        start();
+        await send(context, "control", "DELETE", `${base()}/${signalId}/examples/${encodeURIComponent(conversationId)}`);
+      }
+      return { exitCode: 0 };
+    }
+    case "refine": {
+      assertFlags("signals refine", flags, ["request", "dry-run"]);
+      const signalId = id();
+      const request = flags.request;
+      if (!request || request.length > 2000)
+        throw new CliInputError("--request (1–2000 characters) is required.");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/refine`, { request }, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "revise": {
+      assertFlags("signals revise", flags, ["conversation-ids", "dry-run"]);
+      const signalId = id();
+      const conversationIds = csv(flags["conversation-ids"]);
+      if (!conversationIds)
+        throw new CliInputError("--conversation-ids=a,b is required.");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/revise`, { conversationIds }, { slow: true });
+      return { exitCode: 0 };
+    }
+    case "proposals": {
+      assertFlags("signals proposals", flags, []);
+      const signalId = id();
+      start();
+      await send(context, "control", "GET", `${base()}/${signalId}/proposals`);
+      return { exitCode: 0 };
+    }
+    case "accept":
+    case "reject": {
+      assertFlags(`signals ${sub}`, flags, ["dry-run"]);
+      const signalId = id();
+      const proposalId = id(1, "a proposal id (see `moda signals proposals <id>`)");
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/proposals/${proposalId}/${sub}`);
+      return { exitCode: 0 };
+    }
+    case "search": {
+      assertFlags("signals search", flags, ["mode", "exclude-conversation-ids", "dry-run"]);
+      const signalId = id();
+      start();
+      await send(context, "control", "POST", `${base()}/${signalId}/search`, compact({
+        mode: oneOf("mode", flags.mode, ["wizard", "full"]),
+        excludeConversationIds: csv(flags["exclude-conversation-ids"])
+      }), { slow: true });
+      return { exitCode: 0 };
+    }
+    case "search-status":
+    case "search-stop": {
+      assertFlags(`signals ${sub}`, flags, sub === "search-stop" ? ["dry-run"] : []);
+      const signalId = id();
+      const searchId = id(1, "a search id (returned by `moda signals search <id>`)");
+      start();
+      await send(context, "control", sub === "search-stop" ? "POST" : "GET", `${base()}/${signalId}/searches/${searchId}${sub === "search-stop" ? "/stop" : ""}`);
+      return { exitCode: 0 };
+    }
+    case "preview": {
+      assertFlags("signals preview", flags, ["file", "conversation-ids", "max-examples"]);
+      const body = readBodyFile(flags, context.cwd);
+      if (!body.detector)
+        throw new CliInputError('--file must contain {"detector": {...}} (optionally scope).');
+      start();
+      try {
+        await send(context, "control", "POST", `${base()}/detector-preview`, {
+          ...body,
+          ...compact({
+            conversationIds: csv(flags["conversation-ids"]),
+            maxExamples: flags["max-examples"] !== undefined ? Number(flags["max-examples"]) : undefined
+          })
+        });
+      } catch (error) {
+        if (isTenantFeatureNotFound(error)) {
+          throw new CliAccessError("The signal builder is not enabled for this tenant, so `moda signals preview` is unavailable (the API answered 404).", { guidance: "Ask Moda to enable the signal-builder feature for this tenant. Other `moda signals` subcommands still work." });
+        }
+        throw error;
+      }
+      return { exitCode: 0 };
+    }
+    default:
+      throw unknownSignalsSubcommandError(sub, args);
+  }
+}
+function isTenantFeatureNotFound(error) {
+  if (!(error instanceof ApiError) || error.statusCode !== 404)
+    return false;
+  try {
+    const body = JSON.parse(error.responseBody);
+    return body.message === "Not Found" && body.error === undefined;
+  } catch {
+    return false;
+  }
+}
+var SIGNALS_MANAGEMENT_SUBCOMMANDS = new Set([
+  "draft",
+  "create",
+  "update",
+  "activate",
+  "pause",
+  "delete",
+  "examples",
+  "refine",
+  "revise",
+  "proposals",
+  "accept",
+  "reject",
+  "search",
+  "search-status",
+  "search-stop",
+  "preview"
+]);
+function unknownSignalsSubcommandError(sub, args = []) {
+  if (sub === "archive") {
+    const id = args[0] ?? "<signal_id>";
+    return new CliInputError(`Unknown signals subcommand 'archive': archiving a signal is dashboard-only, so nothing was sent.`, `To stop a signal from running, pause it: moda signals pause ${id}. Drafts can be deleted with moda signals delete ${id}.`);
+  }
+  return new CliInputError(`Unknown signals subcommand '${sub}', so nothing was sent. Valid subcommands: ${[...SIGNALS_MANAGEMENT_SUBCOMMANDS].join(", ")}.`, `Bare 'moda signals' lists custom signals; 'moda signal <signal_id>' opens one. Usage:
+  ${SIGNAL_USAGE}`);
+}
+
+export { ProblemsRemainderSchema, UUID_RE, ProblemImpactSchema, PROBLEM_FEEDBACK_ACTIONS, ProblemFeedbackSchema, ProblemLinearFileSchema, SIGNAL_LABELS, SignalLabelSchema, DETECTION_VERDICTS, DetectionReviewSchema, FALSE_POSITIVE_KINDS, FalsePositiveSchema, StepScoresSchema, AuditSchema, FEEDBACK_USAGE, isFeedbackRefFlag, buildFeedbackRequest, COMMAND_FLAG_SPECS, flagSpecFor, kebabFlag, schemaShape, specFlagKeys, specFlagNames, describeSpecFlags, closestMatches, renderFlagHelp, subcommandHelpFlags, manifestFlagFields, requireTenant, assertFlags, assertPositionals, runUsersCommand, runUserCommand, runProblemReopenCommand, runSignalsManagementCommand, SIGNALS_MANAGEMENT_SUBCOMMANDS, unknownSignalsSubcommandError };