@moda-ai/cli 1.35.0 → 1.37.0

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-7qkhy41j.js";
+} from "./cli-ert1sbbt.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -29,7 +29,8 @@ import {
   summarizeHarness,
   terminalStyles,
   validateHarnessReport
-} from "./cli-0p6n391h.js";
+} from "./cli-07tv75te.js";
+import"./cli-ssfq84k5.js";
 import {
   authFetch,
   clearAuthSession,
@@ -37,7 +38,7 @@ import {
   loadAuthSession,
   login,
   revokeCliSessionToken
-} from "./cli-yz99t7n8.js";
+} from "./cli-strngwn3.js";
 import {
   AGENT_ERROR_CODES,
   CliAccessError,
@@ -55,7 +56,6 @@ import {
   MODA_BASE_URL,
   PROD_BASE_URL,
   VERSION,
-  __require,
   assertValidProfileName,
   clearStoredApiKeyCredentials,
   createCliOutput,
@@ -84,7 +84,10 @@ import {
   validateConfig,
   wasOutputCancelled,
   writeSecretJsonFile
-} from "./cli-drabjmaj.js";
+} from "./cli-q79sq80a.js";
+import {
+  __require
+} from "./cli-0v6na3yp.js";
 
 // src/cli.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -210,6 +213,13 @@ var ProblemFeedbackSchema = z.object({
   new_name: z.string().max(255).optional(),
   actor: z.string().max(255).optional()
 });
+var ProblemLinearFileSchema = z.object({
+  id: z.string().min(1),
+  issue: z.string().max(2048).optional(),
+  team_id: z.string().max(255).optional(),
+  title: z.string().optional(),
+  priority: z.preprocess((v) => typeof v === "string" && /^\d+$/.test(v.trim()) ? Number(v) : v, z.number().int().min(0).max(4).optional())
+});
 var SignalSchema = z.object({
   id: z.string().min(1).max(255),
   detections: boolFlag(),
@@ -234,6 +244,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 +305,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)
 });
@@ -2854,11 +2911,26 @@ async function runAuthCommand(context) {
         return { exitCode: EXIT_AUTH_REQUIRED };
       }
       process.stdout.write(`${session.access_token}
+`);
+      return { exitCode: EXIT_OK };
+    }
+    case "api-key": {
+      const credential = resolveApiKeyCredential({ profile: context.profile, env: context.env });
+      if (!credential) {
+        if (context.flags.json === "true") {
+          process.stdout.write(`${JSON.stringify({ error: "no_api_key" })}
+`);
+        } else {
+          console.error('No API key saved. Run "moda init" (or "moda auth login --api-key-stdin").');
+        }
+        return { exitCode: EXIT_AUTH_REQUIRED };
+      }
+      process.stdout.write(`${credential.key}
 `);
       return { exitCode: EXIT_OK };
     }
     default:
-      throw unknownSubcommandError("auth", subcommand(context), ["login", "logout", "status", "token", "whoami"]);
+      throw unknownSubcommandError("auth", subcommand(context), ["api-key", "login", "logout", "status", "token", "whoami"]);
   }
 }
 async function runProfilesCommand(context) {
@@ -5326,6 +5398,19 @@ function parseFlag(args, index, flags, beforeCommand) {
   flags[key] = "true";
   return index;
 }
+function initFlagsForContext(flags, outputMode, stdinIsTTY) {
+  const args = flagsToArgs(flags);
+  const explicitMode = args.json === true || args.json === "true" || args.agent === true || args.agent === "true";
+  if (explicitMode)
+    return args;
+  if (outputMode === "json")
+    return { ...args, json: true };
+  if (outputMode !== "human")
+    return { ...args, agent: true };
+  if (!stdinIsTTY)
+    return { ...args, non_interactive: true };
+  return args;
+}
 function flagsToArgs(flags, positionalKey, positionalValue) {
   const result = {};
   if (positionalKey && positionalValue) {
@@ -5358,6 +5443,7 @@ Commands:
   auth login --api-key             Non-interactive: validate MODA_API_KEY (or --api-key=<key>) and save it
   auth status                      Show auth state for both credentials (exit 4 when neither is usable); --online probes the API
   auth token                       Print the raw bearer token for $(moda auth token)
+  auth api-key                     Print the saved API key for $(moda auth api-key)
   auth logout                      Clear cached Moda auth
   auth whoami                      Show the authenticated Moda identity (session or API key)
   profiles list                    List local Moda profiles
@@ -5401,12 +5487,17 @@ 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
+  problem-linear <problem_id>      Show the Linear issue linked to a Problem (key, state, URL)
+  problem-linear-file <problem_id> File a Problem as a Linear issue, or link an existing one (--issue)
   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)
@@ -5435,6 +5526,7 @@ Commands:
   skills gen                       Kick off tenant-wide skill generation
   skills status [run-id]           Show a generation run's status, outcome, and recent events (default: latest run)
   skills pull                      Pull tenant-generated skills into .claude/skills (and .cursor/rules)
+  skills install <id...>           Install bundled integration guides into .claude/skills (--list to browse)
   skills pull --status=proposed    Include not-yet-promoted skills (default: approved)
   skills sync                      Push local .claude/skills/**/SKILL.md up to Moda
   skills sync --dry-run            Show what would be pushed without writing
@@ -5516,6 +5608,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 +5626,28 @@ 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
+
+Problem-linear-file flags (needs Linear connected: Integrations -> Linear):
+  --issue=ENG-123|URL              Link an existing Linear issue instead of filing a new one
+  --team-id=ID                     File into this Linear team (default: the integration's default team)
+  --title=TEXT                     Issue title (default: the Problem's name)
+  --priority=N                     0 none, 1 urgent, 2 high, 3 medium, 4 low
+                                   --issue excludes --team-id/--title/--priority
+
 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)
@@ -5604,6 +5719,8 @@ Init flags:
   --no-tui                         Show raw external analyst output
   --sdk-integrate                  Run your coding agent to install the Moda SDK and instrument LLM calls
   --no-sdk-integrate               Skip SDK integration (alias: --no-sdk-guide)
+  --verification-id=ID             Tag the SDK integration's test trace with this id
+                                   (the onb_ id from the Moda onboarding page)
   --ci-cd                          Create GitHub Actions Moda validation workflow
   --no-ci-cd                       Skip CI/CD workflow creation
   --autosync                       Create GitHub Actions workflow to sync prompts + skills to Moda on push to main
@@ -5675,6 +5792,8 @@ Examples:
   moda problems --days-back=7
   moda problem <problem_id> --evidence --limit=10
   moda problem-feedback <problem_id> --action=mark_fixed
+  moda problem-linear <problem_id>
+  moda problem-linear-file <problem_id> --priority=2
   moda detection-reviews <conversation_id>
   moda detection-review <problem_id> --conversation-id=<id> --attribution-id=<uuid> --verdict=false_positive --note="expected retry"
   moda signals
@@ -6032,6 +6151,50 @@ function detectCallerAgent(env) {
     return "agent";
   return "human";
 }
+var LINEAR_CONNECT_GUIDANCE = "Connect Linear in the Moda dashboard (Integrations -> Linear), then retry.";
+function describeLinearLink(linkValue) {
+  const link = asRecord(linkValue);
+  if (!link)
+    return "No Linear issue linked to this Problem.";
+  const issue = asRecord(link.issue);
+  if (!issue) {
+    return "A Linear issue is still being created for this Problem; re-run shortly.";
+  }
+  return [asString(issue.identifier), asString(issue.stateName), asString(issue.url)].filter((part) => part !== null && part !== "").join(" · ");
+}
+function linearApiError(error) {
+  if (!(error instanceof ApiError))
+    return error;
+  let code;
+  let message;
+  try {
+    const body = asRecord(JSON.parse(error.responseBody));
+    code = asString(body?.error) ?? undefined;
+    message = asString(body?.message) ?? undefined;
+  } catch {
+    code = undefined;
+  }
+  if (error.statusCode === 404 && code === "linear_not_enabled") {
+    return new CliAccessError("The Linear integration is not enabled for this tenant.", {
+      guidance: LINEAR_CONNECT_GUIDANCE
+    });
+  }
+  if (error.statusCode === 404 && code === "problem_not_found") {
+    return new CliInputError(`${message ?? "Problem not found"}.`, "Run `moda problems` to list problems with their canonical ids.");
+  }
+  if (error.statusCode === 409 && code === "not_connected") {
+    return new CliAccessError("Linear is not connected, or a disconnect is still in progress.", {
+      guidance: `If Linear was just disconnected, wait for that to finish. ${LINEAR_CONNECT_GUIDANCE}`
+    });
+  }
+  if (error.statusCode === 409 && code === "needs_reauth") {
+    return new CliAccessError("Linear needs to be reconnected.", { guidance: LINEAR_CONNECT_GUIDANCE });
+  }
+  if (error.statusCode === 400 && code === "no_team") {
+    return new CliInputError("No default Linear team is configured.", "Pass --team-id=ID, or set a default team in Integrations -> Linear.");
+  }
+  return error;
+}
 async function runCommand(command, positional, flags, positionals = positional ? [positional] : [], context = createCommandContext({ command, positional, positionals, flags })) {
   switch (command) {
     case "prompts": {
@@ -6404,7 +6567,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() ?? "") === "") {
@@ -6432,6 +6595,72 @@ async function runCommand(command, positional, flags, positionals = positional ?
       context.output.writeData(data);
       break;
     }
+    case "problem-linear": {
+      if (!positional) {
+        throw new CliInputError("<problem_id> is required", "Usage: moda problem-linear <problem_id>");
+      }
+      if (!UUID_RE.test(positional)) {
+        throw new CliInputError(`Problem id must be a canonical UUID; got "${positional}". Run \`moda problems\` to list problems with their canonical ids.`);
+      }
+      const data = await callDataAPI(`/problems/${positional}/linear`).catch((error) => {
+        throw linearApiError(error);
+      });
+      const link = asRecord(data)?.link;
+      const summary = describeLinearLink(link);
+      const nextCommands = link ? [] : [`moda problem-linear-file ${positional}`];
+      if (context.outputMode === "human" && !context.quiet) {
+        safeWriteStderr(link ? `${summary}
+` : `${summary} File one with: moda problem-linear-file ${positional}
+`);
+      }
+      context.output.writeData(data, { summary, nextCommands });
+      break;
+    }
+    case "problem-linear-file": {
+      const usage = "Usage: moda problem-linear-file <problem_id> [--issue=ENG-123|URL] [--team-id=ID] [--title=TEXT] [--priority=0-4]";
+      if (!positional) {
+        throw new CliInputError("<problem_id> is required", usage);
+      }
+      const params = ProblemLinearFileSchema.parse({
+        id: positional,
+        ...flags.issue !== undefined ? { issue: flags.issue } : {},
+        ...flags["team-id"] !== undefined ? { team_id: flags["team-id"] } : {},
+        ...flags.title !== undefined ? { title: flags.title } : {},
+        ...flags.priority !== undefined ? { priority: flags.priority } : {}
+      });
+      if (!UUID_RE.test(params.id)) {
+        throw new CliInputError(`Problem id must be a canonical UUID; got "${params.id}". Run \`moda problems\` to list problems with their canonical ids.`);
+      }
+      const issue = params.issue?.trim() ?? "";
+      if (params.issue !== undefined && issue === "") {
+        throw new CliInputError("--issue must be a Linear issue key (ENG-123) or URL.", usage);
+      }
+      if (issue !== "" && (params.team_id !== undefined || params.title !== undefined || params.priority !== undefined)) {
+        throw new CliInputError("--issue links an existing issue and cannot be combined with --team-id, --title, or --priority.", usage);
+      }
+      const title = params.title?.trim() ?? "";
+      const teamId = params.team_id?.trim() ?? "";
+      const data = await callDataAPI(`/problems/${params.id}/linear`, {
+        method: "POST",
+        body: JSON.stringify(issue !== "" ? { issue } : {
+          ...teamId !== "" ? { team_id: teamId } : {},
+          ...title !== "" ? { title } : {},
+          ...params.priority !== undefined ? { priority: params.priority } : {}
+        }),
+        headers: { "Content-Type": "application/json" }
+      }, { retries: 0 }).catch((error) => {
+        throw linearApiError(error);
+      });
+      const record = asRecord(data);
+      const verb = issue !== "" ? "Linked" : record?.created === true ? "Filed" : "Already linked";
+      const summary = `${verb}: ${describeLinearLink(record?.link)}`;
+      if (context.outputMode === "human" && !context.quiet) {
+        safeWriteStderr(`${summary}
+`);
+      }
+      context.output.writeData(data, { summary });
+      break;
+    }
     case "signals": {
       const data = await callDataAPI("/custom-signals");
       context.output.writeData(data);
@@ -6538,6 +6767,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 +6877,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) {
@@ -6740,7 +7084,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-pf2hvadv.js");
+      const { runInit } = await import("./index-vmmfya6b.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",
@@ -6749,7 +7093,7 @@ var commandRegistry = createCommandRegistry([
           elapsed_ms: Date.now() - context.startedAt
         });
       }
-      const result = await runInit(flagsToArgs(context.flags), {
+      const result = await runInit(initFlagsForContext(context.flags, context.outputMode, process.stdin.isTTY === true), {
         onEvent: (event2) => {
           context.output.writeEvent({
             event: event2.status === "warning" ? "warning" : "progress",
@@ -6781,7 +7125,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result-and-error",
     handler: async (context) => {
-      const { runProvision } = await import("./provision-d242y9qd.js");
+      const { runProvision } = await import("./provision-spwn5t41.js");
       return runProvision(context, {
         resumeCommand: buildResumeCommand("provision", context.rawFlags)
       });
@@ -6820,6 +7164,7 @@ var commandRegistry = createCommandRegistry([
       "moda auth status",
       "moda auth status --online",
       "moda auth token",
+      "moda auth api-key",
       "moda auth whoami",
       "moda auth logout"
     ],
@@ -6881,6 +7226,15 @@ var commandRegistry = createCommandRegistry([
         usage: "moda auth token",
         examples: ["moda auth token", 'curl -H "Authorization: Bearer $(moda auth token)" ...']
       },
+      {
+        name: "api-key",
+        description: "Print the saved API key for $(moda auth api-key); pipe it, never echo it",
+        usage: "moda auth api-key",
+        examples: [
+          'MODA_API_KEY="$(moda auth api-key)" npm run dev',
+          "moda auth api-key | wrangler secret put MODA_API_KEY"
+        ]
+      },
       {
         name: "logout",
         description: "Revoke and clear the browser session and any stored API key",
@@ -7161,6 +7515,23 @@ var commandRegistry = createCommandRegistry([
     ...dataApiDefaults,
     mutability: "write"
   }),
+  legacyCommand({
+    name: "problem-linear",
+    description: "Show the Linear issue linked to a Problem (key, state, URL); needs Linear connected (Integrations -> Linear)",
+    examples: ["moda problem-linear <problem_id>"],
+    ...dataApiDefaults
+  }),
+  legacyCommand({
+    name: "problem-linear-file",
+    description: "File a Problem as a Linear issue in the team's tracker, or link an existing issue with --issue; needs Linear connected (Integrations -> Linear)",
+    examples: [
+      "moda problem-linear-file <problem_id>",
+      'moda problem-linear-file <problem_id> --team-id=<team_id> --title="CRM lookups time out" --priority=2',
+      "moda problem-linear-file <problem_id> --issue=ENG-123"
+    ],
+    ...dataApiDefaults,
+    mutability: "write"
+  }),
   legacyCommand({
     name: "detection-reviews",
     description: "List problem detections on a trace with their review state (correct / false_positive / clear)",
@@ -7181,6 +7552,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 +7618,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",
@@ -7341,7 +7747,14 @@ var commandRegistry = createCommandRegistry([
   {
     name: "skills",
     description: "Generate, pull, and sync Moda skills",
-    examples: ["moda skills gen", "moda skills status", "moda skills pull", "moda skills sync"],
+    examples: [
+      "moda skills gen",
+      "moda skills status",
+      "moda skills pull",
+      "moda skills sync",
+      "moda skills install --list",
+      "moda skills install integration-node-openai"
+    ],
     auth: "none",
     outputModes: ["human", "json", "agent"],
     mutability: "write",
@@ -7662,9 +8075,11 @@ export {
   resolveTailSignal,
   printCliError,
   parseArgs,
+  initFlagsForContext,
   flagsToArgs,
   dispatchParsedCommand,
   detectCallerAgent,
+  describeLinearLink,
   commandRegistry,
   classifyCliError,
   buildResumeCommand,

package/dist/{harness-github-actions-tk17mnge.js → harness-github-actions-qz5d22rz.js}

@@ -1,7 +1,8 @@
 import {
   buildSourceSnapshot
-} from "./cli-0p6n391h.js";
-import"./cli-drabjmaj.js";
+} from "./cli-07tv75te.js";
+import"./cli-q79sq80a.js";
+import"./cli-0v6na3yp.js";
 
 // src/harness-github-actions.ts
 var DEFAULT_MODA_GITHUB_URL = "https://moda-github.modas.workers.dev";