@moda-ai/cli 1.55.8 → 1.55.10

package/dist/{cli-j125g80g.js → cli-v27q5dvh.js}

@@ -27,7 +27,7 @@ import {
   resolveTenantId,
   shouldInventoryFile,
   stringOption
-} from "./cli-mx9r1689.js";
+} from "./cli-0qnghzg4.js";
 import {
   __commonJS,
   __require,
@@ -193384,6 +193384,766 @@ function assertHarnessGraphSyncSize(graph) {
 `));
   }
 }
+// ../../packages/messaging/messaging.json
+var messaging_default = {
+  $schema: "./messaging.schema.json",
+  version: "1.0.3",
+  locked_on: "2026-10-14",
+  approved_by: "mo",
+  source: "Branding project docs/positioning.md v1.0.3",
+  canonical_strings: {
+    version: "1.0.3",
+    locked_on: "2026-10-14",
+    approved_by: "mo",
+    strings: [
+      {
+        id: "one_liner",
+        source: "approved",
+        text: "Moda gives engineers the infrastructure to monitor AI agents in production, find the mistakes they keep repeating, and test every change against real traces before it ships.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/landing/hero.tsx (subhead under the H1)",
+          "apps/moda-frontend/lib/site.ts SITE_DESCRIPTION",
+          "apps/moda-frontend/lib/agent-md.ts MODA_POSITIONING",
+          "apps/moda-frontend/components/seo/json-ld.tsx Organization, WebSite and SoftwareApplication description",
+          "apps/moda-frontend/content/llms/homepage.md",
+          "apps/moda-frontend/app/llms.txt/route.ts (summary line)",
+          "docs/index.mdx frontmatter description",
+          "AGENTS.md and .cursorrules (What Moda Is)",
+          "Y Combinator company page one-liner"
+        ]
+      },
+      {
+        id: "category_label",
+        source: "approved",
+        text: "Production monitoring and evals for AI agents.",
+        match: "contains_ci",
+        surfaces: [
+          "apps/moda-frontend/app/llms.txt/route.ts (after the tagline)",
+          "every bio, package description and directory listing below"
+        ]
+      },
+      {
+        id: "tagline_h1",
+        source: "approved",
+        text: "Your agents should never make the same mistake twice.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/landing/hero.tsx H1",
+          "apps/moda-frontend/lib/agent-md.ts MODA_TAGLINE",
+          "Y Combinator company page headline"
+        ]
+      },
+      {
+        id: "page_title",
+        source: "approved",
+        text: "Moda - Production monitoring and evals for AI agents",
+        match: "exact",
+        max_chars: 60,
+        surfaces: [
+          "apps/moda-frontend/app/layout.tsx metadata.title default",
+          "apps/moda-frontend/app/page.tsx metadata.title",
+          "og:title and twitter:title on the homepage"
+        ]
+      },
+      {
+        id: "faq_lead",
+        source: "approved",
+        text: "Moda helps engineers make sure their agents never make the same mistake twice.",
+        match: "contains_ci",
+        surfaces: [
+          "apps/moda-frontend/lib/faq.ts first answer (also emitted as FAQPage JSON-LD)",
+          "apps/moda-frontend/content/llms/faq.md"
+        ]
+      },
+      {
+        id: "meta_description",
+        source: "derived",
+        text: "Production monitoring and evals for AI agents. Find the mistakes your agents keep repeating and test every change against real traces before it ships.",
+        match: "exact",
+        max_chars: 160,
+        surfaces: [
+          "apps/moda-frontend/app/layout.tsx metadata.description, openGraph.description, twitter.description",
+          "apps/moda-frontend/app/page.tsx metadata.description, openGraph.description, twitter.description"
+        ]
+      },
+      {
+        id: "bio",
+        source: "derived",
+        text: "Production monitoring and evals for AI agents. Your agents should never make the same mistake twice.",
+        match: "exact",
+        max_chars: 120,
+        surfaces: [
+          "X @modaflows bio",
+          "GitHub org ModaLabs bio",
+          "LinkedIn tagline",
+          "Crunchbase short description",
+          "Product Hunt, G2 and other directory taglines"
+        ]
+      },
+      {
+        id: "long_description",
+        source: "derived",
+        text: "Moda gives engineers the infrastructure to monitor AI agents in production, find the mistakes they keep repeating, and test every change against real traces before it ships. Agents fail in ways that never throw an error: frustrated users, failing tools, lazy or hallucinated answers. Moda reads every production trace end to end, detects these failures, and groups them into problems ranked by how many users they affect, with the traces behind each one. When your team changes a prompt, tool, or model, Moda replays the change against those traces and shows whether it worked, then keeps monitoring after release. Works with any model provider through SDKs, OpenTelemetry, or HTTP. Backed by Y Combinator.",
+        match: "exact",
+        surfaces: [
+          "LinkedIn About",
+          "Crunchbase full description",
+          "Y Combinator company page description",
+          "GitHub org profile README (profile/README.md)",
+          "press boilerplate"
+        ]
+      },
+      {
+        id: "sdk_node_description",
+        source: "derived",
+        text: "Official Node.js/TypeScript SDK for Moda: production monitoring and evals for AI agents.",
+        match: "exact",
+        surfaces: [
+          "npm moda-ai package.json description",
+          "GitHub repo description for the Node SDK"
+        ]
+      },
+      {
+        id: "sdk_python_description",
+        source: "derived",
+        text: "Official Python SDK for Moda: production monitoring and evals for AI agents.",
+        match: "exact",
+        surfaces: [
+          "PyPI moda-ai summary (pyproject.toml description)",
+          "GitHub moda-python repo description"
+        ]
+      },
+      {
+        id: "cli_description",
+        source: "derived",
+        text: "CLI for Moda: production monitoring and evals for AI agents.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-cli/package.json description",
+          "apps/moda-cli/README.md first line",
+          "apps/moda-cli/src/tui.ts banner subtitle"
+        ]
+      },
+      {
+        id: "mcp_intro",
+        source: "derived",
+        text: "Moda is production monitoring and evals for AI agents: it ingests your agents' production traces (one trace = one complete agent run) and turns them into ranked problems, detections, and replayable tests.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-mcp/src/instructions.ts SERVER_INSTRUCTIONS first sentence"
+        ]
+      },
+      {
+        id: "init_prompt_line",
+        source: "derived",
+        text: "Add the Moda SDK to this project so its AI agents are monitored in production.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-cli/src/init/sdk-integration.ts prompt header",
+          "apps/moda-onboarding-evals/prompts/integrate.md first line"
+        ]
+      },
+      {
+        id: "schema_service_type",
+        source: "derived",
+        text: "Production monitoring and evals for AI agents",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/seo/json-ld.tsx Service serviceType"
+        ]
+      },
+      {
+        id: "directory_categories",
+        source: "derived",
+        text: "AI agent monitoring; LLM evaluation",
+        match: "exact",
+        surfaces: [
+          "G2, Product Hunt, There's An AI For That and other directory category fields: primary first, secondary second"
+        ]
+      },
+      {
+        id: "pillar_1",
+        source: "derived",
+        title: "Monitor every trace",
+        text: "Moda reads every production trace end to end and detects the failures that never throw an error: frustrated users, failing tools, lazy answers, and hallucinations. Add your own checks in plain language and get alerts in Slack, Linear, or email.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/landing/features.tsx pillar 1",
+          "sales one-pager"
+        ]
+      },
+      {
+        id: "pillar_2",
+        source: "derived",
+        title: "Find the mistakes they keep repeating",
+        text: "Failures are grouped into problems ranked by how many users they affect. Each problem shows the traces behind it, the turn where it went wrong, and related problems that share the cause.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/landing/features.tsx pillar 2",
+          "sales one-pager"
+        ]
+      },
+      {
+        id: "pillar_3",
+        source: "derived",
+        title: "Test every change before it ships",
+        text: "Replay a prompt, model, or tool change against the exact traces that failed and compare pass rate, latency, and tokens. Your team reviews the result and decides what ships.",
+        match: "exact",
+        surfaces: [
+          "apps/moda-frontend/components/landing/features.tsx pillar 3",
+          "sales one-pager"
+        ]
+      }
+    ]
+  },
+  banned_phrases: {
+    version: "1.0.3",
+    phrases: [
+      {
+        id: "fixes_your_agent",
+        pattern: "\\b(fix(es|ing)?|repair(s|ing)?) your (ai )?agents?\\b|\\b(moda|we) (fix|fixes|repair|repairs)\\b",
+        reason: "Moda never claims to fix agents itself; engineers fix their agents",
+        replacement: "test your fix against real traces",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "auto_fix",
+        pattern: "\\bauto[- ]?fix(es|ing|ed)?\\b|\\bautonomous(ly)? fix|\\bself[- ]heal(ing|s)?\\b|\\bfixes itself\\b",
+        reason: "Implies Moda changes agents without engineers",
+        replacement: "test your change against real traces",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "moda_opens_prs",
+        pattern: "\\b(moda|we) (can |will |then |also )?(opens?|creates?|files?|raises?|submits?|sends?|delivers?|drafts?|proposes?|suggests?|writes?) (a |an |the )?(draft |candidate |proposed |verified )?(fix(es)?|pull requests?|PRs?|code changes?|code fix(es)?|patch(es)?)\\b|\\b(moda|we) (can |will |then |also )?(drafts?|proposes?|suggests?) (a |an |the )?(candidate |proposed )?changes?\\b|\\bfix PRs?\\b|\\bdraft (pull requests?|PRs?)\\b",
+        reason: "Moda does not open pull requests, write fix PRs or propose code fixes; engineers make the change",
+        replacement: "engineers make the change; Moda tests it against real traces",
+        allowed_contexts: [
+          "competitor_comparison",
+          "negation"
+        ]
+      },
+      {
+        id: "learns",
+        pattern: "\\blearns\\b|\\blearn(s|ing)? from (production|every|each|your)\\b|\\bagents? that learn\\b|\\bself[- ]learning\\b",
+        reason: "Learning claims are visionary framing; Moda monitors, finds and tests. Navigation text such as 'Learn more' is allowed because it does not match",
+        replacement: "find the mistakes your agents keep repeating",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "continual_learning",
+        pattern: "\\bcontinual[- ]learning\\b|\\blearning (layer|loop)\\b",
+        reason: "Undefined buzzword to buyers; rejected Oct 14",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: [
+          "competitor_comparison",
+          "keyword_list"
+        ]
+      },
+      {
+        id: "self_improving",
+        pattern: "\\bself[- ]improv(e|es|ing|ement)\\b|\\bimprov(e|es) (itself|themselves)\\b|\\bget(s)? better (on (its|their) own|automatically|every week)\\b",
+        reason: "Implies autonomy and roadmap capability",
+        replacement: "test every change against real traces",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "roadmap_training",
+        pattern: "\\bfine[- ]?tun(e|es|ed|ing)\\b|\\btrain(s|ing|ed)? (your|the|their) (models?|agents?)\\b|\\bmodel training\\b|\\bweight updates?\\b",
+        reason: "Not shipped",
+        replacement: "(none)",
+        allowed_contexts: [
+          "negation",
+          "internal",
+          "keyword_list"
+        ]
+      },
+      {
+        id: "roadmap_rl",
+        pattern: "\\breinforcement learning\\b|\\bRLHF\\b|\\bRLAIF\\b|\\bRL\\b|\\breward models?\\b|\\bprocess reward\\b|\\bPRM\\b",
+        case_sensitive: true,
+        reason: "Not shipped. Case-sensitive so the word 'url' does not match",
+        replacement: "(none)",
+        allowed_contexts: [
+          "negation",
+          "internal"
+        ]
+      },
+      {
+        id: "roadmap_inference",
+        pattern: "\\bhosted inference\\b|\\binference (platform|hosting|fleet)\\b|\\b(we|moda) (serve|host)s? (your )?models?\\b",
+        reason: "Not shipped",
+        replacement: "(none)",
+        allowed_contexts: [
+          "negation",
+          "internal"
+        ]
+      },
+      {
+        id: "visionary_framing",
+        pattern: "\\blatent space\\b|\\boutside the (model )?weights\\b|\\bthe future of\\b|\\bnext[- ]gen(eration)?\\b|\\brevolutioni[sz]",
+        reason: "Describe only what ships today",
+        replacement: "(describe the shipped feature)",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "layer_category",
+        pattern: "\\b(learning|intelligence|reliability|data) layer\\b|\\blayer for ai agents\\b",
+        reason: "Vague infrastructure noun from retired positioning",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: []
+      },
+      {
+        id: "observability_category",
+        pattern: "\\b(llm|ai|agent|ai agent) observability\\b|\\bobservability (platform|for ai|for agents|for llm)|\\bobservability-grade\\b",
+        reason: "mo rejected observability as the pitch; names a data layer, not the job",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: [
+          "competitor_comparison",
+          "keyword_list",
+          "skill_trigger"
+        ]
+      },
+      {
+        id: "product_analytics",
+        pattern: "\\b(ai |llm )?product analytics\\b|\\bconversation analytics\\b|\\banalytics platform\\b|\\banalytics and observability\\b",
+        reason: "mo rejected product analytics; signals a PM buyer",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: [
+          "competitor_comparison",
+          "keyword_list",
+          "skill_trigger"
+        ]
+      },
+      {
+        id: "llm_native_software",
+        pattern: "\\bllm-native software\\b|\\bchatbots, copilots, agents\\b",
+        reason: "Dated audience framing",
+        replacement: "AI agents in production",
+        allowed_contexts: []
+      },
+      {
+        id: "harness_category",
+        pattern: "\\bharness engineering\\b|\\bautonomous harness\\b|\\bobservability for agent harnesses\\b",
+        reason: "Retired by PR #5696. 'Agent harness' remains allowed as a technical noun in docs and product UI",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: [
+          "internal"
+        ]
+      },
+      {
+        id: "reliability_category",
+        pattern: "\\breliability platform\\b|\\bmonitoring (&|and) reliability\\b",
+        reason: "Rejected category label; the approved label is fixed",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: []
+      },
+      {
+        id: "agent_improvement_category",
+        pattern: "\\bagent improvement (platform|layer)\\b|\\bdata engine for\\b",
+        reason: "Rejected category labels",
+        replacement: "production monitoring and evals for AI agents",
+        allowed_contexts: []
+      },
+      {
+        id: "sentry_for_ai",
+        pattern: "\\bsentry for ai\\b",
+        reason: "Raindrop's tagline",
+        replacement: "(none)",
+        allowed_contexts: [
+          "competitor_comparison"
+        ]
+      },
+      {
+        id: "gateway",
+        pattern: "\\bllm api gateway\\b|\\bgateway and pub-sub\\b",
+        reason: "Product from an earlier era",
+        replacement: "(none)",
+        allowed_contexts: []
+      }
+    ]
+  },
+  terminology: {
+    version: "1.0.3",
+    terms: [
+      {
+        use: "trace",
+        avoid: [
+          "conversation (as the product noun)",
+          "session"
+        ],
+        note: "Renamed in MODA-1793. API and tool parameter names may keep conversation_id"
+      },
+      {
+        use: "AI agents",
+        avoid: [
+          "LLM apps",
+          "chatbots",
+          "copilots"
+        ],
+        note: "Audience noun in all marketing copy"
+      },
+      {
+        use: "problem",
+        avoid: [
+          "issue",
+          "incident"
+        ],
+        note: "A group of recurring failures ranked by users affected"
+      },
+      {
+        use: "signal",
+        avoid: [
+          "metric",
+          "classifier"
+        ],
+        note: "A detection that runs on every trace"
+      },
+      {
+        use: "custom signal",
+        avoid: [
+          "custom metric",
+          "judge"
+        ],
+        note: "A plain-language check the team writes"
+      },
+      {
+        use: "use case",
+        avoid: [
+          "cluster (in marketing copy)"
+        ],
+        note: "Cluster stays fine in docs and the product UI"
+      },
+      {
+        use: "replay",
+        avoid: [
+          "simulation"
+        ],
+        note: "Running a change against real traces"
+      },
+      {
+        use: "monitor",
+        avoid: [],
+        note: "Product feature name and the category verb"
+      },
+      {
+        use: "evals",
+        avoid: [
+          "evaluations (in headlines)"
+        ],
+        note: "Category word; 'evaluation' is fine in body text"
+      },
+      {
+        use: "fix (engineer as the actor)",
+        avoid: [
+          "Moda fixes",
+          "auto-fix",
+          "fix PRs",
+          "Moda opens a PR",
+          "Moda drafts a fix"
+        ],
+        note: "A change engineers make. Moda tests it against real traces; it does not draft fixes or open pull requests"
+      }
+    ]
+  }
+};
+
+// ../../packages/messaging/src/matchers.ts
+var normalizeCopy = (text) => text.replace(/\s+/g, " ").trim();
+function matchCanonical(text, entry) {
+  const copy = normalizeCopy(text);
+  const canonical = normalizeCopy(entry.text);
+  if (entry.match === "exact" && copy === canonical)
+    return "exact";
+  return copy.toLowerCase().includes(canonical.toLowerCase()) ? "contains" : null;
+}
+var ALLOW_MARKER = /messaging-allow:\s*([a-z_]+)/g;
+var escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var terminologyPattern = (avoid) => {
+  const words = normalizeCopy(avoid.replace(/\([^)]*\)/g, " "));
+  return words ? new RegExp(`(?<![\\w-])${escapeRegExp(words)}(?![\\w-])`, "gi") : null;
+};
+var distinct = (values) => [...new Set(values)];
+function createMatchers(messaging) {
+  const banned = messaging.banned_phrases.phrases.map((phrase) => ({
+    phrase,
+    regex: new RegExp(phrase.pattern, phrase.case_sensitive ? "g" : "gi")
+  }));
+  const terms = messaging.terminology.terms.flatMap((term) => term.avoid.flatMap((avoid) => {
+    const regex = terminologyPattern(avoid);
+    return regex ? [{ term, avoid, regex }] : [];
+  }));
+  return {
+    findBannedPhrases(text) {
+      const markers = new Set([...text.matchAll(ALLOW_MARKER)].map((match) => match[1]));
+      return banned.flatMap(({ phrase, regex }) => {
+        const matches = distinct([...text.matchAll(regex)].map((match) => match[0]));
+        if (matches.length === 0)
+          return [];
+        const allowedBy = phrase.allowed_contexts.find((context) => markers.has(context)) ?? null;
+        return [{ phrase, matches, allowedBy }];
+      });
+    },
+    findTerminology(text) {
+      return terms.flatMap(({ term, avoid, regex }) => {
+        const matches = distinct([...text.matchAll(regex)].map((match) => match[0]));
+        return matches.length ? [{ term, avoid, matches }] : [];
+      });
+    },
+    findCanonical(text) {
+      return messaging.canonical_strings.strings.flatMap((entry) => {
+        const relation = matchCanonical(text, entry);
+        return relation ? [{ entry, relation }] : [];
+      });
+    }
+  };
+}
+// ../../packages/messaging/messaging.schema.json
+var messaging_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://moda.dev/schemas/messaging.schema.json",
+  title: "Moda locked positioning",
+  description: "packages/messaging/messaging.json: the canonical-strings, banned-phrases and terminology blocks of the locked positioning doc. Regenerate with `bun run --cwd packages/messaging sync -- <positioning.md>`.",
+  type: "object",
+  required: ["version", "locked_on", "approved_by", "source", "canonical_strings", "banned_phrases", "terminology"],
+  additionalProperties: false,
+  properties: {
+    $schema: { type: "string" },
+    version: { $ref: "#/$defs/version" },
+    locked_on: { $ref: "#/$defs/date" },
+    approved_by: { type: "string", minLength: 1 },
+    source: { type: "string", minLength: 1 },
+    canonical_strings: {
+      type: "object",
+      required: ["version", "locked_on", "approved_by", "strings"],
+      additionalProperties: false,
+      properties: {
+        version: { $ref: "#/$defs/version" },
+        locked_on: { $ref: "#/$defs/date" },
+        approved_by: { type: "string", minLength: 1 },
+        strings: { type: "array", items: { $ref: "#/$defs/canonicalString" } }
+      }
+    },
+    banned_phrases: {
+      type: "object",
+      required: ["version", "phrases"],
+      additionalProperties: false,
+      properties: {
+        version: { $ref: "#/$defs/version" },
+        phrases: { type: "array", items: { $ref: "#/$defs/bannedPhrase" } }
+      }
+    },
+    terminology: {
+      type: "object",
+      required: ["version", "terms"],
+      additionalProperties: false,
+      properties: {
+        version: { $ref: "#/$defs/version" },
+        terms: { type: "array", items: { $ref: "#/$defs/term" } }
+      }
+    }
+  },
+  $defs: {
+    version: { type: "string", pattern: "^\\d+\\.\\d+\\.\\d+$" },
+    date: { type: "string", pattern: "^\\d{4}-\\d{2}-\\d{2}$" },
+    canonicalString: {
+      type: "object",
+      required: ["id", "source", "text", "match", "surfaces"],
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", pattern: "^[a-z0-9_]+$" },
+        source: { enum: ["approved", "derived"] },
+        title: { type: "string", minLength: 1 },
+        text: { type: "string", minLength: 1 },
+        match: {
+          enum: ["exact", "contains_ci"],
+          description: "exact: the live text equals text after trimming whitespace. contains_ci: the live text contains text, case-insensitively."
+        },
+        surfaces: { type: "array", items: { type: "string", minLength: 1 } },
+        max_chars: { type: "integer", minimum: 1 }
+      }
+    },
+    bannedPhrase: {
+      type: "object",
+      required: ["id", "pattern", "reason", "replacement", "allowed_contexts"],
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", pattern: "^[a-z0-9_]+$" },
+        pattern: { type: "string", minLength: 1, description: "A JavaScript regular expression, case-insensitive unless case_sensitive is true." },
+        case_sensitive: { type: "boolean" },
+        reason: { type: "string", minLength: 1 },
+        replacement: { type: "string", minLength: 1 },
+        allowed_contexts: {
+          type: "array",
+          items: { enum: ["competitor_comparison", "keyword_list", "skill_trigger", "negation", "internal"] }
+        }
+      }
+    },
+    term: {
+      type: "object",
+      required: ["use", "avoid", "note"],
+      additionalProperties: false,
+      properties: {
+        use: { type: "string", minLength: 1 },
+        avoid: { type: "array", items: { type: "string", minLength: 1 } },
+        note: { type: "string" }
+      }
+    }
+  }
+};
+
+// ../../packages/messaging/src/schema.ts
+var KNOWN_KEYWORDS = new Set([
+  "$schema",
+  "$id",
+  "$defs",
+  "$ref",
+  "title",
+  "description",
+  "type",
+  "required",
+  "additionalProperties",
+  "properties",
+  "items",
+  "enum",
+  "pattern",
+  "minLength",
+  "minimum"
+]);
+var root = messaging_schema_default;
+var withArticle = (word) => `${/^[aeiou]/.test(word) ? "an" : "a"} ${word}`;
+var typeOf = (value) => value === null ? "null" : Array.isArray(value) ? "array" : Number.isInteger(value) ? "integer" : typeof value;
+function check(value, node, path, problems) {
+  const unknown = Object.keys(node).filter((keyword) => !KNOWN_KEYWORDS.has(keyword));
+  if (unknown.length) {
+    problems.push(`messaging.schema.json uses unsupported keywords at ${path}: ${unknown.join(", ")}`);
+    return;
+  }
+  if (node.$ref) {
+    const name = node.$ref.replace(/^#\/\$defs\//, "");
+    const target = root.$defs[name];
+    if (!target)
+      problems.push(`messaging.schema.json has no definition ${node.$ref}`);
+    else
+      check(value, target, path, problems);
+    return;
+  }
+  if (node.enum && !node.enum.includes(value)) {
+    problems.push(`${path} is ${JSON.stringify(value)}, expected one of ${node.enum.map((entry) => JSON.stringify(entry)).join(", ")}`);
+    return;
+  }
+  if (node.type) {
+    const actual = typeOf(value);
+    if (actual !== node.type) {
+      problems.push(`${path} is ${actual === "undefined" ? "missing" : withArticle(actual)}, expected ${withArticle(node.type)}`);
+      return;
+    }
+  }
+  if (typeof value === "string") {
+    if (node.minLength !== undefined && value.length < node.minLength)
+      problems.push(`${path} must not be empty`);
+    if (node.pattern && !new RegExp(node.pattern, "u").test(value))
+      problems.push(`${path} "${value}" does not match ${node.pattern}`);
+  }
+  if (typeof value === "number" && node.minimum !== undefined && value < node.minimum)
+    problems.push(`${path} is below ${node.minimum}`);
+  if (Array.isArray(value) && node.items) {
+    value.forEach((entry, index) => check(entry, node.items, `${path}[${index}]`, problems));
+  }
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const record = value;
+    for (const key of node.required ?? []) {
+      if (!(key in record))
+        problems.push(`${path}.${key} is missing`);
+    }
+    for (const [key, entry] of Object.entries(record)) {
+      const child = node.properties?.[key];
+      if (child)
+        check(entry, child, `${path}.${key}`, problems);
+      else if (node.additionalProperties === false)
+        problems.push(`${path}.${key} is not allowed`);
+    }
+  }
+}
+function schemaProblems(value) {
+  const problems = [];
+  check(value, root, "messaging", problems);
+  return problems;
+}
+
+// ../../packages/messaging/src/positioning-doc.ts
+function validateMessaging(messaging) {
+  const shape = schemaProblems(messaging);
+  if (shape.length > 0)
+    return shape;
+  const problems = [];
+  const { canonical_strings: canonical, banned_phrases: banned, terminology } = messaging;
+  for (const [name, version] of [
+    ["canonical_strings", canonical.version],
+    ["banned_phrases", banned.version],
+    ["terminology", terminology.version]
+  ]) {
+    if (version !== messaging.version)
+      problems.push(`${name}.version is ${version}, expected ${messaging.version}`);
+  }
+  const ids = new Set;
+  for (const entry of canonical.strings) {
+    const label = `canonical string ${entry.id}`;
+    if (ids.has(entry.id))
+      problems.push(`${label} is listed twice`);
+    ids.add(entry.id);
+    if (entry.max_chars !== undefined && entry.text.length > entry.max_chars) {
+      problems.push(`${label} is ${entry.text.length} characters, over its max_chars of ${entry.max_chars}`);
+    }
+  }
+  const phraseIds = new Set;
+  for (const phrase of banned.phrases) {
+    const label = `banned phrase ${phrase.id}`;
+    if (phraseIds.has(phrase.id))
+      problems.push(`${label} is listed twice`);
+    phraseIds.add(phrase.id);
+    try {
+      if (new RegExp(phrase.pattern, phrase.case_sensitive ? "" : "i").test(""))
+        problems.push(`${label} matches empty text`);
+    } catch (error) {
+      problems.push(`${label} has an invalid pattern: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return problems;
+}
+
+// ../../packages/messaging/src/index.ts
+var problems = validateMessaging(messaging_default);
+if (problems.length > 0)
+  throw new Error(`packages/messaging/messaging.json is invalid:
+- ${problems.join(`
+- `)}`);
+var messaging = messaging_default;
+var CANONICAL_STRINGS = messaging.canonical_strings.strings;
+var BANNED_PHRASES = messaging.banned_phrases.phrases;
+var TERMINOLOGY = messaging.terminology.terms;
+var matchers2 = createMatchers(messaging);
+function canonicalString(id) {
+  const entry = CANONICAL_STRINGS.find((candidate) => candidate.id === id);
+  if (!entry)
+    throw new Error(`Unknown canonical string "${id}"`);
+  return entry;
+}
+function canonicalText(id) {
+  return canonicalString(id).text;
+}
+
 // src/tui.ts
 var STATUS_LABELS = {
   pass: "ok",
@@ -193411,8 +194171,8 @@ function renderDoctorHuman(report, options = {}) {
   for (const [group, checks] of groupChecks(report.checks)) {
     lines.push("");
     lines.push(ui.section(titleCase(group)));
-    for (const check of checks) {
-      lines.push(renderCheck(ui, check));
+    for (const check2 of checks) {
+      lines.push(renderCheck(ui, check2));
     }
   }
   if (report.nextCommands.length > 0) {
@@ -193473,7 +194233,7 @@ function renderInitBanner() {
   const ui = createTerminalUi();
   return [
     ui.title("Moda init"),
-    ui.dim("LLM observability for agent harnesses"),
+    ui.dim(canonicalText("cli_description")),
     "",
     `  ${ui.status("info")} Human-in-the-loop setup. Secrets stay untouched and file changes are shown before completion.`
   ].join(`
@@ -193631,27 +194391,27 @@ function renderSummary(ui, report) {
     `skip ${report.summary.skipped}`
   ].join("  ");
 }
-function renderCheck(ui, check) {
+function renderCheck(ui, check2) {
   const lines = [];
-  lines.push(`  ${ui.status(check.status)} ${check.title}`);
-  for (const evidence of check.evidence.slice(0, 4)) {
+  lines.push(`  ${ui.status(check2.status)} ${check2.title}`);
+  for (const evidence of check2.evidence.slice(0, 4)) {
     lines.push(ui.wrap(`      ${evidence.label}: ${evidence.value}`, 6));
   }
-  if (check.remediation) {
-    lines.push(ui.wrap(`      fix: ${check.remediation}`, 6));
+  if (check2.remediation) {
+    lines.push(ui.wrap(`      fix: ${check2.remediation}`, 6));
   }
-  if (check.nextCommand) {
-    lines.push(`      next: ${ui.command(check.nextCommand)}`);
+  if (check2.nextCommand) {
+    lines.push(`      next: ${ui.command(check2.nextCommand)}`);
   }
   return lines.join(`
 `);
 }
 function groupChecks(checks) {
   const groups = new Map;
-  for (const check of checks) {
-    const existing = groups.get(check.group) ?? [];
-    existing.push(check);
-    groups.set(check.group, existing);
+  for (const check2 of checks) {
+    const existing = groups.get(check2.group) ?? [];
+    existing.push(check2);
+    groups.set(check2.group, existing);
   }
   return [...groups.entries()];
 }
@@ -194017,7 +194777,7 @@ async function runHarnessCommand(context) {
         throw new CliInputError("Focused remote prompt analysis is not supported yet.", "Use local --analyst=claude|codex|cursor|local-scan, or drop --concern for a full remote report.");
       }
       if (context.flags["github-actions"] === "true") {
-        const { runGithubActionsAnalyze } = await import("./harness-github-actions-t4m8q3wn.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-wpkr7jjr.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -194624,7 +195384,7 @@ function extractHarnessReportFromText(output, rootDir, concern) {
 }
 function reportJsonCandidates(output) {
   const candidates = [];
-  const markerPattern = new RegExp(`${escapeRegExp(REPORT_JSON_BEGIN)}\\s*([\\s\\S]*?)\\s*${escapeRegExp(REPORT_JSON_END)}`, "g");
+  const markerPattern = new RegExp(`${escapeRegExp2(REPORT_JSON_BEGIN)}\\s*([\\s\\S]*?)\\s*${escapeRegExp2(REPORT_JSON_END)}`, "g");
   for (const match of output.matchAll(markerPattern)) {
     if (match[1])
       candidates.push(match[1]);
@@ -194891,7 +195651,7 @@ function extractTextFromAgentEvent(event) {
   return textParts.length > 0 ? textParts.join(`
 `) : undefined;
 }
-function escapeRegExp(value) {
+function escapeRegExp2(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 var EVENT_CARD_MAX = 100;
@@ -196052,17 +196812,17 @@ function collectSnapshotInputs(rootDir, maxFiles, maxTextBytes) {
   return inputs;
 }
 function buildSourceSnapshot(rootDir) {
-  const root = resolve14(rootDir);
+  const root2 = resolve14(rootDir);
   const maxFiles = numericEnv("MODA_HARNESS_MAX_FILES", DEFAULT_MAX_INVENTORY_FILES);
   const maxTextBytes = numericEnv("MODA_HARNESS_MAX_TEXT_BYTES", DEFAULT_MAX_INVENTORY_TEXT_BYTES);
-  const inputs = collectSnapshotInputs(root, maxFiles, maxTextBytes);
-  const repo = detectRepo(root, inputs.map((input) => ({
+  const inputs = collectSnapshotInputs(root2, maxFiles, maxTextBytes);
+  const repo = detectRepo(root2, inputs.map((input) => ({
     path: input.path,
-    absPath: join10(root, input.path),
-    rootDir: root,
+    absPath: join10(root2, input.path),
+    rootDir: root2,
     text: input.text
   })));
-  const gitCommit = getGitCommit(root);
+  const gitCommit = getGitCommit(root2);
   return packSnapshot(inputs, {
     repoName: repo.name,
     ...gitCommit ? { gitCommit } : {},
@@ -198062,4 +198822,4 @@ function hashText(text) {
   return createHash7("sha256").update(text).digest("hex");
 }
 
-export { isPlatformApiKey, setPlatformTenantOverride, apiKeyHeaders, ApiError, callDataAPI, callControlAPI, $isSeq, $parseDocument, $stringify, require_typescript, inspectCodeSelectors, inspectPythonSelectors, resolvePromptSource, backfillPromptSource, HARNESS_REPORT_PATH, HARNESS_REPORT_APPROVAL_PATH, HARNESS_ANALYZE_CONCERNS, validateHarnessReport, readHarnessReport, normalizeHarnessReport, hashHarnessReport, hashStableJson, assertFlags, assertPositionals, runUsersCommand, runUserCommand, runProblemReopenCommand, runSignalsManagementCommand, SIGNALS_MANAGEMENT_SUBCOMMANDS, unknownSignalsSubcommandError, shouldColorTerminalOutput, terminalStyles, stripAnsi2 as stripAnsi, renderMarkdownForTerminal, startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, renderDoctorHuman, renderStatusHuman, renderInitBanner, renderInitStep, renderInitNote, renderInitSetupPlan, renderInitComplete, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, repairExternalAnalystReport, deriveRelationshipsFromGraph, mergeDeterministicArtifacts, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, readHarnessSyncState, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId2 as stableId, titleFromId2 as titleFromId, promptNameFromPath };
+export { isPlatformApiKey, setPlatformTenantOverride, apiKeyHeaders, ApiError, callDataAPI, callControlAPI, $isSeq, $parseDocument, $stringify, require_typescript, inspectCodeSelectors, inspectPythonSelectors, resolvePromptSource, backfillPromptSource, HARNESS_REPORT_PATH, HARNESS_REPORT_APPROVAL_PATH, HARNESS_ANALYZE_CONCERNS, validateHarnessReport, readHarnessReport, normalizeHarnessReport, hashHarnessReport, hashStableJson, assertFlags, assertPositionals, runUsersCommand, runUserCommand, runProblemReopenCommand, runSignalsManagementCommand, SIGNALS_MANAGEMENT_SUBCOMMANDS, unknownSignalsSubcommandError, shouldColorTerminalOutput, terminalStyles, stripAnsi2 as stripAnsi, renderMarkdownForTerminal, startRemoteAnalyze, pollRemoteAnalyzeUntilDone, isRecoverableRemoteRun, checkPromptMapping, safePromptEvidencePath, discoverHarnessPromptSources, canonicalText, renderDoctorHuman, renderStatusHuman, renderInitBanner, renderInitStep, renderInitNote, renderInitSetupPlan, renderInitComplete, runHarnessCommand, writeHarnessAnalyzeResult, emitWrittenArtifacts, analyzeHarnessPrompts, repairExternalAnalystReport, deriveRelationshipsFromGraph, mergeDeterministicArtifacts, describeCodingAgentEvent, analystEventProgress, isRetryableExternalAnalystFailure, sleep, summarizeInvalidAnalystReport, isDeterministicLocalAnalyst, resolveHarnessAnalyzeConcern, detectAvailableCodingAgents, codingAgentDisplayName, runCodingAgent, resolveAnalystModel, renderExternalHarnessAnalystPrompt, CONCERN_CANDIDATE_KINDS, SEED_CANDIDATE_KIND_LABELS, renderAnalystCandidateLines, renderAnalystSeedLines, truncateText, scanHarness, summarizeHarness, buildSourceSnapshot, writeHumanProgress, readHarnessSyncState, describeSyncIdentity, describeSyncTenantLabel, findFresherHarnessReports, writeHarnessArtifacts, assertHarnessGraphSyncQuality, graphForSync, inventoryFiles, numericEnv, numericEnvAllowZero, computeDeterministicFloor, stableId2 as stableId, titleFromId2 as titleFromId, promptNameFromPath };