@moda-ai/cli 1.55.27 → 1.55.28

package/dist/cli-xq45etg1.js

@@ -0,0 +1,1098 @@
+// ../../packages/messaging/messaging.json
+var messaging_default = {
+  $schema: "./messaging.schema.json",
+  version: "1.0.4",
+  locked_on: "2026-10-15",
+  approved_by: "mo",
+  source: "Branding project docs/positioning.md v1.0.4",
+  canonical_strings: {
+    version: "1.0.4",
+    locked_on: "2026-10-15",
+    approved_by: "mo",
+    strings: [
+      {
+        id: "one_liner",
+        source: "approved",
+        text: "Infrastructure for catching AI agent mistakes in production and turning them into evals.",
+        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. Infrastructure for catching AI agent mistakes in production and turning them into evals.",
+        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: "Infrastructure for catching AI agent mistakes in production and turning them into evals. 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.4",
+    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.4",
+    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",
+  warning: "warn",
+  fail: "fail",
+  skipped: "skip",
+  info: "info",
+  run: "run"
+};
+var STATUS_COLORS = {
+  pass: 32,
+  warning: 33,
+  fail: 31,
+  skipped: 90,
+  info: 36,
+  run: 35
+};
+function renderDoctorHuman(report, options = {}) {
+  const ui = createTerminalUi(options);
+  const lines = [];
+  lines.push(ui.title("Moda doctor"));
+  lines.push(ui.dim(`Profile ${report.profile.active}${report.profile.requested ? ` (requested ${report.profile.requested})` : ""}`));
+  lines.push("");
+  lines.push(renderSummary(ui, report));
+  for (const [group, checks] of groupChecks(report.checks)) {
+    lines.push("");
+    lines.push(ui.section(titleCase(group)));
+    for (const check2 of checks) {
+      lines.push(renderCheck(ui, check2));
+    }
+  }
+  if (report.nextCommands.length > 0) {
+    lines.push("");
+    lines.push(ui.section("Next commands"));
+    for (const command of report.nextCommands.slice(0, 8)) {
+      lines.push(`  ${ui.command(command)}`);
+    }
+  }
+  if (report.fixPlan.length > 0) {
+    lines.push("");
+    lines.push(ui.section("Repair plan"));
+    for (const item of report.fixPlan.slice(0, 8)) {
+      const command = item.command ? ` ${ui.command(item.command)}` : "";
+      lines.push(ui.wrap(`  - ${item.action}${command}`, 4));
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderStatusHuman(status, options = {}) {
+  const ui = createTerminalUi(options);
+  const lines = [];
+  lines.push(ui.title("Moda status"));
+  lines.push(`${ui.status(status.status)} ${ui.dim(`profile ${status.activeProfile}`)}`);
+  lines.push("");
+  lines.push(`Auth        ${status.auth.apiKey}`);
+  lines.push(`Tenant      ${status.workspace.tenantId ?? "missing"}`);
+  lines.push(`Base URL    ${status.workspace.baseUrl}`);
+  lines.push(`Ingest URL  ${status.workspace.ingestUrl}`);
+  lines.push("");
+  lines.push(ui.section("Readiness"));
+  lines.push(`  Data flow       ${ui.status(status.dataFlow)}`);
+  lines.push(`  Harness         ${ui.status(status.harness)}`);
+  lines.push(`  Harness sync    ${ui.status(status.harnessSync)}`);
+  lines.push(`  Shadow Spark    ${ui.status(status.shadowSpark)}`);
+  lines.push(`  Prompts         ${ui.status(status.prompts)}`);
+  lines.push(`  Skills          ${ui.status(status.skills)}`);
+  if (status.topBrokenCheck) {
+    lines.push("");
+    lines.push(ui.section("Attention"));
+    lines.push(`  ${ui.status(status.topBrokenCheck.status)} ${status.topBrokenCheck.id}`);
+    if (status.topBrokenCheck.nextCommand) {
+      lines.push(`  Next: ${ui.command(status.topBrokenCheck.nextCommand)}`);
+    }
+  }
+  if (status.nextCommands.length > 0) {
+    lines.push("");
+    lines.push(ui.section("Next commands"));
+    for (const command of status.nextCommands) {
+      lines.push(`  ${ui.command(command)}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function renderInitBanner() {
+  const ui = createTerminalUi();
+  return [
+    ui.title("Moda init"),
+    ui.dim(canonicalText("cli_description")),
+    "",
+    `  ${ui.status("info")} Human-in-the-loop setup. Secrets stay untouched and file changes are shown before completion.`
+  ].join(`
+`);
+}
+function renderInitStep(index, total, title, detail) {
+  const ui = createTerminalUi();
+  return [
+    "",
+    ui.section(`Step ${index}/${total}: ${title}`),
+    ...detail ? [ui.wrap(`  ${detail}`, 2)] : []
+  ].join(`
+`);
+}
+function renderInitNote(message, status = "pass") {
+  const ui = createTerminalUi();
+  return `  ${ui.status(status)} ${message}`;
+}
+function renderInitSetupPlan(actions, options = {}) {
+  const ui = createTerminalUi();
+  const lines = actions.map((action) => {
+    const status = action.approved ? "pass" : action.status === "manual" ? "skipped" : "warning";
+    const suffix = action.reason ? ` - ${action.reason}` : "";
+    return ui.wrap(`  ${ui.status(status)} ${action.title}${suffix}`, 4);
+  });
+  if (options.snapshotConsent) {
+    lines.push("");
+    lines.push(ui.wrap(`  ${ui.status("info")} Moda will analyze a snapshot of this repo on Moda's servers to map your agent harness. Secrets and .env files are excluded and the snapshot is deleted after the run.`, 4));
+  }
+  return lines.join(`
+`);
+}
+function renderInitComplete(options) {
+  const ui = createTerminalUi();
+  const dashboardUrl = options.dashboardUrl ?? "https://moda.dev";
+  const lines = [];
+  lines.push("");
+  lines.push(ui.title(`Workspace ready: ${options.tenantName}`));
+  lines.push(`Dashboard: ${ui.command(dashboardUrl)}`);
+  lines.push("");
+  if (options.harness?.state === "pending") {
+    lines.push(ui.wrap(`  ${ui.status("run")} Harness analysis is still running on Moda. Run ${ui.command("moda harness pull --sync")} in a few minutes.`, 4));
+  } else if (options.harness?.state === "skipped") {
+    const what = {
+      unavailable: "Harness analysis did not start and was skipped.",
+      lost: "Lost track of the harness analysis; it may still be running on Moda.",
+      unfetched: "Harness analysis finished on Moda but could not be fetched.",
+      failed: "Harness analysis failed on Moda and was skipped."
+    }[options.harness.reason ?? "unavailable"];
+    lines.push(ui.wrap(`  ${ui.status("warning")} ${what} Run ${ui.command(options.harness.next ?? "moda harness pull --sync")} later.`, 4));
+  } else if (options.harness) {
+    lines.push(ui.wrap(`  ${ui.status("pass")} Harness mapped: ${options.harness.agents ?? 0} agent(s), ${options.harness.artifacts ?? 0} artifact(s). View: ${ui.command(dashboardUrl)}`, 4));
+  }
+  lines.push("");
+  lines.push(ui.section("Files changed"));
+  if (options.filesChanged.length === 0) {
+    lines.push(`  ${ui.dim("none")}`);
+  } else {
+    for (const file of options.filesChanged)
+      lines.push(`  ${file}`);
+  }
+  if (options.skipped.length > 0) {
+    lines.push("");
+    lines.push(ui.section("Skipped or manual"));
+    for (const action of options.skipped) {
+      lines.push(ui.wrap(`  - ${action.title}: ${action.reason ?? action.status}`, 4));
+    }
+  }
+  lines.push("");
+  lines.push(ui.section("Next steps"));
+  if (options.telemetrySeen === true) {
+    lines.push(`  Telemetry is flowing. Explore it: ${ui.command("moda overview")}`);
+  } else {
+    lines.push(`  Run your app to send telemetry, then: ${ui.command("moda doctor --online")}`);
+  }
+  lines.push(`  Ask about your agents: ${ui.command('moda ask "what did my agents do today?"')}`);
+  return lines.join(`
+`);
+}
+function renderHarnessProgress(message, status = "run") {
+  const ui = createTerminalUi();
+  return `${ui.status(status)} ${message}`;
+}
+function renderHarnessAnalystPreflight(options) {
+  const ui = createTerminalUi();
+  const lines = [];
+  lines.push(ui.section("Analyst read plan"));
+  lines.push(`  ${ui.status("info")} Moda Analyst will inspect this project before any sync.`);
+  lines.push(`  Root       ${options.root}`);
+  lines.push(ui.wrap(`  Reads      ${options.willRead.join(", ")}`, 12));
+  lines.push(ui.wrap(`  Skips      ${options.willSkip.join(", ")}`, 12));
+  lines.push(`  Writes     ${ui.dim("none during investigation; Moda writes .moda artifacts after validation")}`);
+  return lines.join(`
+`);
+}
+function renderHarnessAnalystLaunch(options) {
+  const ui = createTerminalUi();
+  const lines = [];
+  lines.push(ui.section("Moda Analyst"));
+  lines.push(`  ${ui.status("run")} Launching ${options.adapterName}`);
+  lines.push(`  Command    ${options.command}`);
+  lines.push(`  Mode       read-only repository access`);
+  lines.push(`  Root       ${options.root}`);
+  lines.push(`  Output     ${options.reportPath}`);
+  lines.push(`  Boundary   Agent can inspect files and print a cited report. Moda validates it, then writes .moda artifacts.`);
+  return lines.join(`
+`);
+}
+function renderHarnessAnalystChoice(options) {
+  const ui = createTerminalUi();
+  return [
+    ui.section("Detected coding agents"),
+    `  ${ui.status("info")} ${options.detected.join(", ")}`,
+    "  Pick the agent that should investigate this repo in read-only mode."
+  ].join(`
+`);
+}
+function renderHarnessAnalyzeHumanResult(data) {
+  const ui = createTerminalUi();
+  const value = asRecord(data);
+  const summary = asRecord(value?.summary);
+  const validation = asRecord(value?.validation);
+  const written = Array.isArray(value?.written) ? value.written.map(String) : [];
+  const lines = [];
+  lines.push(ui.title("Moda Analyst report"));
+  lines.push(`${ui.status(validation?.status === "fail" ? "fail" : "pass")} validation ${String(validation?.status ?? "unknown")}`);
+  if (summary) {
+    lines.push("");
+    lines.push(ui.section("Harness summary"));
+    lines.push(`  Runtime agents  ${numberOrZero(summary.runtimeAgentCount)}`);
+    lines.push(`  Agent families  ${numberOrZero(summary.agentFamilyCount)}`);
+    lines.push(`  Artifacts       ${numberOrZero(summary.artifactCount ?? summary.sharedArtifactCount)}`);
+    lines.push(`  Providers       ${numberOrZero(summary.modelProviderCount)}`);
+    lines.push(`  Unknowns        ${numberOrZero(summary.unknownCount)}`);
+  }
+  if (written.length > 0) {
+    lines.push("");
+    lines.push(ui.section("Artifacts"));
+    for (const file of written.slice(0, 12))
+      lines.push(`  ${file}`);
+  }
+  lines.push("");
+  lines.push(ui.section("Next commands"));
+  lines.push(`  ${ui.command("moda harness approve --yes")}`);
+  lines.push(`  ${ui.command("moda harness sync --from-report .moda/harness-report.json --dry-run")}`);
+  return lines.join(`
+`);
+}
+function renderSummary(ui, report) {
+  return [
+    ui.status(report.summary.status),
+    `pass ${report.summary.pass}`,
+    `warn ${report.summary.warning}`,
+    `fail ${report.summary.fail}`,
+    `skip ${report.summary.skipped}`
+  ].join("  ");
+}
+function renderCheck(ui, check2) {
+  const lines = [];
+  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 (check2.remediation) {
+    lines.push(ui.wrap(`      fix: ${check2.remediation}`, 6));
+  }
+  if (check2.nextCommand) {
+    lines.push(`      next: ${ui.command(check2.nextCommand)}`);
+  }
+  return lines.join(`
+`);
+}
+function groupChecks(checks) {
+  const groups = new Map;
+  for (const check2 of checks) {
+    const existing = groups.get(check2.group) ?? [];
+    existing.push(check2);
+    groups.set(check2.group, existing);
+  }
+  return [...groups.entries()];
+}
+function titleCase(value) {
+  return value.split(/[-_\s]+/).filter(Boolean).map((part) => `${part.slice(0, 1).toUpperCase()}${part.slice(1)}`).join(" ");
+}
+function numberOrZero(value) {
+  return typeof value === "number" && Number.isFinite(value) ? String(value) : "0";
+}
+function asRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createTerminalUi(options = {}) {
+  const width = Math.max(48, Math.min(options.width ?? process.stdout.columns ?? 96, 140));
+  const color = options.color ?? Boolean(process.stdout.isTTY && process.env.NO_COLOR !== "1");
+  const paint = (code, text) => color ? `\x1B[${code}m${text}\x1B[0m` : text;
+  return {
+    title: (text) => paint(1, text),
+    section: (text) => paint(36, text),
+    status: (status) => paint(STATUS_COLORS[status], `[${STATUS_LABELS[status]}]`),
+    command: (text) => paint(36, text),
+    dim: (text) => paint(90, text),
+    wrap: (text, indent) => wrapLine(text, width, indent)
+  };
+}
+function wrapLine(text, width, indent) {
+  if (text.length <= width)
+    return text;
+  const lead = text.match(/^\s*/)?.[0] ?? "";
+  const words = text.trimStart().split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const next = current ? `${current} ${word}` : `${lead}${word}`;
+    if (next.length > width && current) {
+      lines.push(current);
+      current = `${" ".repeat(indent)}${word}`;
+    } else {
+      current = next;
+    }
+  }
+  if (current)
+    lines.push(current);
+  return lines.join(`
+`);
+}
+
+// src/harness-sync-state.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+var SYNC_STATE_PATH = join(".moda", "sync-state.json");
+function readHarnessSyncState(rootDir) {
+  const path = join(rootDir, SYNC_STATE_PATH);
+  if (!existsSync(path))
+    return;
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.schemaVersion !== "sync_state.v0.1") {
+      return;
+    }
+    return parsed;
+  } catch {
+    return;
+  }
+}
+
+export { canonicalText, renderDoctorHuman, renderStatusHuman, renderInitBanner, renderInitStep, renderInitNote, renderInitSetupPlan, renderInitComplete, renderHarnessProgress, renderHarnessAnalystPreflight, renderHarnessAnalystLaunch, renderHarnessAnalystChoice, renderHarnessAnalyzeHumanResult, SYNC_STATE_PATH, readHarnessSyncState };