@moda-ai/cli 1.28.5 → 1.28.6

package/dist/{cli-g931ntph.js → cli-793dhrgb.js}

@@ -3153,6 +3153,8 @@ async function runHarnessCommand(context) {
         if (!approved && !context.dryRun) {
           throw new CliInputError("Harness report is not approved; refusing to sync.", "Run `moda harness validate-report`, review the report, then run `moda harness approve --yes` before syncing.");
         }
+        if (!context.dryRun)
+          assertHarnessGraphSyncQuality(report.graph, context.flags);
         const syncGraph2 = graphForReport(report.graph);
         const sourceCommit2 = report.source.sourceCommit ?? getGitCommit(rootDir);
         const localGraphHash2 = hashStableJson(syncGraph2);
@@ -3233,6 +3235,8 @@ async function runHarnessCommand(context) {
         tenantSource: tenant?.source,
         pathWasExplicit: context.flags.path !== undefined
       });
+      if (!context.dryRun)
+        assertHarnessGraphSyncQuality(graph, context.flags);
       const syncGraph = graphForSync(graph);
       const sourceCommit = getGitCommit(rootDir);
       const localGraphHash = hashStableJson2(syncGraph);
@@ -3338,7 +3342,7 @@ async function runHarnessCommand(context) {
         elapsed_ms: Date.now() - context.startedAt
       });
       if (context.flags["github-actions"] === "true") {
-        const { runGithubActionsAnalyze } = await import("./harness-github-actions-ct8fwzdr.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-wd1ahhxz.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -3669,7 +3673,7 @@ async function runExternalHarnessAnalyst(options) {
       reportPath: HARNESS_REPORT_PATH
     }));
   }
-  const timeoutMs = numericEnv("MODA_HARNESS_ANALYST_TIMEOUT_MS", 1200000);
+  const timeoutMs = numericEnv("MODA_HARNESS_ANALYST_TIMEOUT_MS", 1800000);
   try {
     const result = await runExternalAnalystWithRetries(invocation, {
       cwd: options.rootDir,
@@ -3799,10 +3803,25 @@ function readExternalAnalystReport(rootDir, result, adapter) {
   const parsed = extractHarnessReportFromText(output, rootDir);
   if (parsed)
     return parsed;
+  let debugHint = "";
+  try {
+    const debugPath = resolve4(rootDir, MODA_DIR, "analyst-debug.log");
+    mkdirSync3(dirname4(debugPath), { recursive: true });
+    writeFileSync3(debugPath, [
+      `# analyst=${adapter} status=${result.status} signal=${result.signal} timedOut=${result.timedOut} maxBufferExceeded=${result.maxBufferExceeded}`,
+      "# ----- stdout -----",
+      result.stdout,
+      "# ----- stderr -----",
+      result.stderr
+    ].join(`
+`));
+    debugHint = `Raw analyst output saved to ${join2(MODA_DIR, "analyst-debug.log")} for debugging.`;
+  } catch {}
   throw new CliInputError(`Harness analyst ${adapter} did not return a harness report.`, [
     `Expected ${HARNESS_REPORT_PATH} or final JSON between ${REPORT_JSON_BEGIN} and ${REPORT_JSON_END}.`,
+    debugHint,
     "Retry with the selected coding agent CLI fixed, choose another analyst, or run `moda harness analyze --analyst=local-scan --summary` for deterministic fallback."
-  ].join(`
+  ].filter(Boolean).join(`
 `));
 }
 function extractHarnessReportFromText(output, rootDir) {
@@ -4112,7 +4131,7 @@ function isRetryableExternalAnalystFailure(result) {
     return false;
   const output = `${result.stdout}
 ${result.stderr}`;
-  return /\b529\b|overloaded|server-side issue|temporar(?:y|ily)|try again|rate limit|too many requests|\b429\b|service unavailable/i.test(output);
+  return /\b529\b|\b429\b|\b5(?:00|02|03|04)\b|overloaded|server-side issue|temporar(?:y|ily)|try again|rate limit|too many requests|service unavailable|internal server error|connection (?:closed|reset|error)|mid-response|econnreset|econnrefused|etimedout|socket hang ?up|fetch failed|network error|stream (?:closed|disconnected|error)/i.test(output);
 }
 function externalAnalystMaxAttempts(adapter) {
   const defaultRetries = adapter === "claude" ? 2 : 1;
@@ -4352,12 +4371,14 @@ function resolveExternalHarnessAnalystInvocation(options) {
   }
   if (options.adapter === "claude") {
     const extraArgs = externalAnalystExtraArgs(options.adapter);
-    const permission = mode === "write" ? ["--permission-mode", "acceptEdits", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash"] : ["--permission-mode", "plan", "--allowedTools", "Read,Grep,Glob,Bash(pwd),Bash(ls *),Bash(find *),Bash(rg *),Bash(grep *),Bash(cat *),Bash(git status *),Bash(git ls-files *),Bash(git grep *)"];
+    const model = resolveAnalystModel(options.adapter, options.flags);
+    const permission = mode === "write" ? ["--permission-mode", "acceptEdits", "--allowedTools", "Read,Grep,Glob,Edit,Write,Bash"] : ["--allowedTools", `Read,Grep,Glob,Write(${HARNESS_REPORT_PATH}),Bash(pwd),Bash(ls *),Bash(find *),Bash(rg *),Bash(grep *),Bash(cat *),Bash(git status *),Bash(git ls-files *),Bash(git grep *)`];
     return {
       adapter: options.adapter,
       command,
       args: [
         "--print",
+        ...model ? ["--model", model] : [],
         ...extraArgs,
         ...permission,
         ...options.stream ? ["--verbose"] : [],
@@ -4418,7 +4439,7 @@ async function runCodingAgent(options) {
     stream,
     mode: options.mode
   });
-  const timeoutMs = options.timeoutMs ?? numericEnv("MODA_HARNESS_ANALYST_TIMEOUT_MS", 1200000);
+  const timeoutMs = options.timeoutMs ?? numericEnv("MODA_HARNESS_ANALYST_TIMEOUT_MS", 1800000);
   const result = await runExternalAnalystWithRetries(invocation, {
     cwd: options.rootDir,
     env: buildExternalAnalystEnv(options.env ?? process.env),
@@ -4447,24 +4468,34 @@ async function runCodingAgent(options) {
 function externalAnalystExtraArgs(adapter) {
   return splitCommandLine(process.env[`MODA_HARNESS_ANALYST_${adapter.toUpperCase()}_ARGS`] ?? "");
 }
+var DEFAULT_CLAUDE_ANALYST_MODEL = "sonnet";
+function resolveAnalystModel(adapter, flags) {
+  const flagValue = flags["analyst-model"] && flags["analyst-model"] !== "true" ? flags["analyst-model"] : undefined;
+  const raw = (flagValue ?? process.env.MODA_HARNESS_ANALYST_MODEL)?.trim();
+  if (raw?.toLowerCase() === "default")
+    return;
+  if (raw)
+    return raw;
+  return adapter === "claude" ? DEFAULT_CLAUDE_ANALYST_MODEL : undefined;
+}
 function renderExternalHarnessAnalystPrompt(options) {
   return [
     "You are Moda Analyst, investigating an agent harness for Moda CLI onboarding.",
     "",
-    "Do real repository investigation. Do not call `moda harness scan`, `moda harness analyze`, or rely on deterministic Moda scanner output.",
+    "Do real repository investigation. Do not call `moda harness scan` or `moda harness analyze` yourself. When Moda provides deterministic scanner seeds below, treat them as navigation candidates to verify against the real files — never as evidence or as a complete inventory.",
     "Only inspect the Repository root named below and files/directories under it. Do not inspect parent directories, sibling projects, the Moda CLI implementation, or this monorepo unless the Repository root itself is that directory.",
     "Inspect package manifests, source files, prompt files, tool definitions, skills/rules, evals, deployment config, and README/AGENTS docs as needed.",
     "Do not read secret-looking files such as .env files, private keys, credential files, or token stores.",
     "You are running as a read-only analyst. Do not edit source files, configuration files, git state, dependency files, or project metadata.",
-    "Prefer printing the final report JSON for Moda CLI to validate and write. If your runtime unexpectedly allows file writes, only `.moda/harness-report.json` is permitted.",
+    `The ONLY path you may write is ${HARNESS_REPORT_PATH}. Write the final report JSON there with the Write tool as soon as it is complete — the file is the durable deliverable and survives a dropped connection, unlike a long printed message. If (and only if) the write fails, print the report JSON between the sentinel markers instead.`,
     "",
     "Your task:",
     renderExternalAnalystProtocol(),
     "1. Identify the runtime agent harnesses, agent families, channel adapters, identity mappings, model providers, frameworks, deployments, and open questions.",
     "2. Exhaustively enumerate EVERY prompt, tool, guardrail, and eval as its own graph artifact — the complete inventory, not a sample. This report feeds prompt optimization and tool optimization, so a missing tool or prompt is a real defect. Runtime agents may be modeled representatively on framework/example repos, but prompts and tools must be complete.",
     "3. Cite every narrative claim with local file paths, exact line numbers, and excerpts. File citations without line numbers are invalid for agent-authored reports. Enumerated artifacts only need evidence:[{path, reason}], so completeness of the artifact inventory is not limited by the citation cap.",
-    `4. After completing investigation, print the report JSON between ${REPORT_JSON_BEGIN} and ${REPORT_JSON_END}. Moda CLI will validate it and write the local artifacts.`,
-    "Your final response must contain the sentinel-wrapped JSON report. Do not end with commentary about being read-only, do not summarize without JSON, and do not omit the sentinel markers.",
+    `4. After completing investigation, WRITE the report JSON to ${HARNESS_REPORT_PATH} with the Write tool, then print a one-line confirmation naming the file. Only if that write fails, print the report JSON between ${REPORT_JSON_BEGIN} and ${REPORT_JSON_END}. Moda CLI validates whichever it finds (the file wins).`,
+    "Do not end with commentary about being read-only and do not summarize without delivering the report: either the written file or the sentinel-wrapped JSON must exist before you finish.",
     "If the repository is very large, keep enumerating prompts/tools/guardrails/evals as artifacts (uncapped) and only summarize runtime AGENTS representatively — do not drop tools or prompts to save space.",
     "",
     "Final output format:",
@@ -4491,7 +4522,7 @@ function renderExternalHarnessAnalystPrompt(options) {
     "Each graph item with evidence must use evidence: [{ path, reason }], not citationIds/citations.",
     'Runtime agents must include id, name, kind:"runtime_agent", root, entrypointIds, channelAdapterIds, artifactIds, identityNamespaceIds, deploymentIds, frameworkIds, modelProviderIds, confidence, evidence.',
     "Artifacts must include id, type, name, scope, usedByAgentIds, confidence, evidence, and optional sourcePath/contentHash/ownedByAgentId. Emit one artifact PER tool, PER prompt (including each inline system prompt), PER guardrail, and PER eval — enumerate them all; artifact types are entrypoint, prompt, tool, skill, eval, retrieval_index, memory, guardrail, model_config, unknown.",
-    "Also set `body` on each artifact to its actual usable content so it can be consumed downstream WITHOUT re-reading the repo: for `prompt` the COMPLETE prompt text verbatim (full inline `instructions=`/system-prompt string or full prompt file); for `tool` the signature (name + parameters + types) and its docstring/description; for `guardrail` the rule/condition; for `eval` what it asserts; for `model_config` the configuration values. Copy the text in full — do not summarize or truncate `body` (it is the artifact we optimize). Redact any secret literals.",
+    "Do NOT transcribe prompt/tool text into `body` when it exists verbatim in the repo — pin its exact location instead (sourcePath for a dedicated file, or evidence [{ path, line, reason }] at the definition line) and Moda hydrates `body` locally from that location after validation. Set `body` inline ONLY for content that cannot be recovered from one pinned location: dynamically assembled prompts, fragments concatenated at runtime, or values you had to derive. Short bodies for `guardrail` (the rule), `eval` (what it asserts), and `model_config` (the config values) are still welcome. Redact any secret literals.",
     "For every `prompt` and `tool` artifact, at least one evidence entry MUST pin an exact source location so downstream optimization can retrieve the item text: carry a numeric `line` (the definition line, or the first line of the range) — evidence: [{ path, line, reason }]. The only exception is an artifact whose entire dedicated file is the text (e.g. a standalone prompt file); set its sourcePath and cite that same file and no line is required. When a single file holds multiple inline prompts or tool definitions, give each its own distinct line — a bare { path, reason } is a defect there.",
     "Agent families must include id, name, runtimeAgentIds, sharedArtifactIds, confidence, evidence.",
     "Frameworks/providers must include packageNames and runtimeAgentIds arrays; providers also include envVars and modelHints arrays.",
@@ -4502,6 +4533,7 @@ function renderExternalHarnessAnalystPrompt(options) {
     options.tenantId ? `Tenant ID to include in graph.tenant: ${options.tenantId}` : "No tenant ID was provided for this analysis.",
     `Repository root: ${options.rootDir}`,
     renderAnalystPreflightSection(options.rootDir),
+    renderAnalystSeedSection(options.rootDir),
     "",
     "Be conservative. If something is unclear, put it in unknowns instead of inventing an agent."
   ].filter(Boolean).join(`
@@ -4520,7 +4552,7 @@ function renderExternalAnalystProtocol() {
     '- Also emit artifacts for guardrails (type "guardrail"), evals/tests-of-agents (type "eval"), memory/session stores (type "memory"), retrieval indexes (type "retrieval_index"), and model configuration (type "model_config").',
     "- Only runtime AGENTS may be modeled representatively: if the repo is a framework/SDK/examples collection, you need not treat every example as a distinct production agent — but you MUST still enumerate every distinct tool, prompt, guardrail, and eval as its own artifact.",
     "- Each enumerated artifact needs evidence: [{ path, reason }] (file path + short reason); a full line+excerpt citation is required only for the narrative `claims`, NOT for every artifact — so listing hundreds of tools/prompts is cheap and expected.",
-    "- Capture the actual usable content in each artifact's `body`: full prompt text for prompts, signature+docstring for tools, the rule for guardrails, the assertion for evals, config values for model configs. This inventory is consumed directly for optimization, so `body` must be the complete text (verbatim, not summarized), with secret literals redacted.",
+    "- Bodies are hydrated locally by Moda from pinned locations — do not copy file text into `body`. Spend your output budget on coverage (every artifact, exact definition locations), not transcription. Inline `body` only for content not recoverable from a single location (e.g. prompts assembled from fragments at runtime), plus short bodies for guardrails/evals/model configs.",
     "- EXCEPTION — `prompt` and `tool` artifacts MUST pin an exact location: put a numeric `line` on at least one evidence entry (evidence: [{ path, line, reason }]) at the definition line. That structured location is what lets downstream optimization retrieve the exact prompt/tool text; when one file has several inline prompts or tools, each artifact gets its own line. The only case that needs no line is a whole dedicated file whose entire content is the artifact (set sourcePath to that file and cite it). Still no excerpt required — just the line.",
     "- For every runtime agent, read and cite at least one concrete entrypoint or orchestration line, and link its prompts/tools via artifactIds.",
     "- Keep going until every prompt, tool, guardrail, and eval in scope is represented as an artifact. Use unknowns only for genuinely ambiguous items — never to skip enumeration. Respect the hard caps (<=250 claims, <=400 citations): artifacts are uncapped, so when there are many items keep enumerating them as artifacts and reserve claims/citations for the most important ones."
@@ -4528,7 +4560,7 @@ function renderExternalAnalystProtocol() {
 `);
 }
 function renderAnalystPreflightSection(rootDir) {
-  if (process.env.MODA_HARNESS_ANALYST_PREFLIGHT !== "1")
+  if (process.env.MODA_HARNESS_ANALYST_PREFLIGHT === "0")
     return "";
   const paths = listAnalystPreflightPaths(rootDir);
   if (paths.length === 0)
@@ -4558,6 +4590,91 @@ function renderPreflightGroup(label, paths) {
     return [];
   return [`${label}:`, ...paths.map((path) => `- ${path}`)];
 }
+var MAX_SEED_ARTIFACT_LINES = 150;
+function renderAnalystSeedSection(rootDir) {
+  if (process.env.MODA_HARNESS_ANALYST_SEEDS === "0")
+    return "";
+  const sections = [];
+  try {
+    const lines = renderAnalystSeedLines(scanHarness({ rootDir, dryRun: true, pathWasExplicit: true }));
+    if (lines)
+      sections.push(lines);
+  } catch {}
+  try {
+    const lines = renderAnalystCandidateLines(detectHarnessCandidates(rootDir));
+    if (lines)
+      sections.push(lines);
+  } catch {}
+  return sections.join(`
+`);
+}
+var MAX_SEED_CANDIDATES_PER_KIND = 40;
+var MAX_SEED_READ_PLAN_FILES = 25;
+var SEED_CANDIDATE_KIND_LABELS = {
+  llm_call_site: "LLM call sites",
+  framework_construct: "Agent-framework constructs",
+  tool_definition: "Tool definitions",
+  tool_schema: "Tool schemas",
+  message_construction: "Message constructions",
+  prompt_file: "Prompt files",
+  prompt_literal: "Inline prompt literals",
+  model_config: "Model configuration"
+};
+function renderAnalystCandidateLines(report) {
+  if (report.candidates.length === 0)
+    return "";
+  const byKind = new Map;
+  for (const candidate of report.candidates) {
+    const bucket = byKind.get(candidate.kind);
+    if (bucket)
+      bucket.push(candidate);
+    else
+      byKind.set(candidate.kind, [candidate]);
+  }
+  const lines = [
+    "",
+    `Deterministic candidate inventory (${report.candidates.length} candidates across ${report.stats.filesWithCandidates} files, scanned in ${report.stats.durationMs}ms):`,
+    "Each entry is path:line [detector] excerpt. Verify each candidate against the real file, then represent every confirmed tool/prompt/eval/model-config as a graph artifact pinned to that location. Candidates are pattern matches — drop false positives, and investigate what patterns cannot see (agent topology, relationships, prompts assembled at runtime). Do not cite this list as evidence; cite the files."
+  ];
+  for (const [kind, label] of Object.entries(SEED_CANDIDATE_KIND_LABELS)) {
+    const bucket = byKind.get(kind);
+    if (!bucket || bucket.length === 0)
+      continue;
+    const shown = bucket.slice(0, MAX_SEED_CANDIDATES_PER_KIND);
+    lines.push(`${label} (${bucket.length}${bucket.length > shown.length ? `, showing ${shown.length}` : ""}):`);
+    for (const candidate of shown) {
+      lines.push(`- ${candidate.path}:${candidate.startLine} [${candidate.signal}] ${candidate.excerpt}`);
+    }
+  }
+  const readPlan = report.files.slice(0, MAX_SEED_READ_PLAN_FILES);
+  if (readPlan.length > 0) {
+    lines.push(`Highest-signal files to read first (${readPlan.length} of ${report.files.length}):`, ...readPlan.map((file) => `- ${file.path} (score ${Math.round(file.score)}; ${file.kinds.join(", ")})`));
+  }
+  return lines.join(`
+`);
+}
+function renderAnalystSeedLines(graph) {
+  const providers = graph.modelProviders.map((provider) => `- ${provider.name}${provider.packageNames.length ? ` (packages: ${provider.packageNames.join(", ")})` : ""}`);
+  const frameworks = graph.agentFrameworks.map((framework) => `- ${framework.name}${framework.packageNames.length ? ` (packages: ${framework.packageNames.join(", ")})` : ""}`);
+  const artifacts = graph.artifacts.slice(0, MAX_SEED_ARTIFACT_LINES).map((artifact) => `- [${artifact.type}] ${artifact.sourcePath ?? artifact.name}`);
+  if (providers.length === 0 && frameworks.length === 0 && artifacts.length === 0)
+    return "";
+  const lines = [
+    "",
+    "Deterministic scanner seeds (candidates, not ground truth):",
+    "Moda's static scanner pre-detected the items below from package manifests and filename patterns. Verify each against the real files before including it, correct or drop mislabeled entries, and focus your investigation on what pattern matching cannot see: runtime agents, inline prompts, decorated/registered tool definitions, and the relationships between them. Do not cite this list as evidence."
+  ];
+  if (providers.length > 0)
+    lines.push("Detected model providers:", ...providers);
+  if (frameworks.length > 0) {
+    lines.push("Detected agent frameworks (package-name matches; may be false positives):", ...frameworks);
+  }
+  if (artifacts.length > 0) {
+    lines.push(`Detected artifact candidates (${graph.artifacts.length} total${graph.artifacts.length > MAX_SEED_ARTIFACT_LINES ? `, showing first ${MAX_SEED_ARTIFACT_LINES}` : ""}):`, ...artifacts);
+  }
+  return lines.join(`
+`);
+}
 function listAnalystPreflightPaths(rootDir) {
   const gitPaths = readGitTrackedPaths(rootDir);
   const paths = gitPaths.length > 0 ? gitPaths : readDirectoryPreflightPaths(rootDir);
@@ -5257,6 +5374,25 @@ function renderFrameworkAndProviderLines(graph) {
   }
   return lines;
 }
+function assertHarnessGraphSyncQuality(graph, flags) {
+  if (flags["allow-no-agents"] === "true")
+    return;
+  if (graph.runtimeAgents.length > 0)
+    return;
+  const evidence = [];
+  if (graph.modelProviders.length > 0) {
+    evidence.push(`model providers (${graph.modelProviders.map((provider) => provider.name).join(", ")})`);
+  }
+  if (graph.agentFrameworks.length > 0) {
+    evidence.push(`agent frameworks (${graph.agentFrameworks.map((framework) => framework.name).join(", ")})`);
+  }
+  const promptOrToolCount = graph.artifacts.filter((artifact) => artifact.type === "prompt" || artifact.type === "tool").length;
+  if (promptOrToolCount > 0)
+    evidence.push(`${promptOrToolCount} prompt/tool artifacts`);
+  if (evidence.length === 0)
+    return;
+  throw new CliInputError(`Refusing to sync: the harness graph has zero runtime agents but detected ${evidence.join(", ")}.`, "Agent detection likely under-ran (the deterministic scanner only finds agents via @moda annotations). Run `moda harness analyze --analyst=claude` for semantic detection, or pass --allow-no-agents to sync this graph anyway.");
+}
 function graphForSync(graph) {
   return sortJson2({
     ...graph,

package/dist/{cli-x1a56ws9.js → cli-n5qz81m0.js}

@@ -11,7 +11,7 @@ import {
   renderStatusHuman,
   scanHarness,
   validateHarnessReport
-} from "./cli-g931ntph.js";
+} from "./cli-793dhrgb.js";
 import {
   isAuthSessionValid,
   loadAuthSession

package/dist/cli.js

@@ -8,7 +8,7 @@ import {
   runPromptsCommand,
   runSkillsCommand,
   runStatusCommand
-} from "./cli-x1a56ws9.js";
+} from "./cli-n5qz81m0.js";
 import {
   ApiError,
   HARNESS_REPORT_APPROVAL_PATH,
@@ -29,7 +29,7 @@ import {
   summarizeHarness,
   terminalStyles,
   validateHarnessReport
-} from "./cli-g931ntph.js";
+} from "./cli-793dhrgb.js";
 import {
   authFetch,
   clearAuthSession,
@@ -5499,6 +5499,11 @@ Init flags:
   --yes                            Accept all defaults (non-interactive)
   --analyst=auto|claude|codex|cursor|local-scan
                                    Choose harness analyst adapter
+  --analyst-model=MODEL            Model for the claude analyst (default: sonnet;
+                                   "default" = the claude CLI's own default;
+                                   env: MODA_HARNESS_ANALYST_MODEL)
+  --allow-no-agents                Allow harness sync to push a graph with zero
+                                   runtime agents despite detected LLM usage
   --remote                         Run harness analysis server-side (Moda-hosted,
                                    the default): upload a safe source snapshot; no
                                    local coding agent required
@@ -6491,7 +6496,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result",
     handler: async (context) => {
-      const { runInit } = await import("./index-g3gt62rm.js");
+      const { runInit } = await import("./index-djg29jhz.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",

package/dist/{harness-github-actions-ct8fwzdr.js → harness-github-actions-wd1ahhxz.js}

@@ -1,6 +1,6 @@
 import {
   buildSourceSnapshot
-} from "./cli-g931ntph.js";
+} from "./cli-793dhrgb.js";
 import"./cli-59yacef3.js";
 
 // src/harness-github-actions.ts

package/dist/{index-g3gt62rm.js → index-djg29jhz.js}

@@ -9,7 +9,7 @@ import {
   runPromptSync,
   runSkillSync,
   upsertSkillManifestRecord
-} from "./cli-x1a56ws9.js";
+} from "./cli-n5qz81m0.js";
 import {
   codingAgentDisplayName,
   describeCodingAgentEvent,
@@ -27,7 +27,7 @@ import {
   runHarnessCommand,
   startRemoteAnalyze,
   stripAnsi
-} from "./cli-g931ntph.js";
+} from "./cli-793dhrgb.js";
 import {
   selectTenantAndCreateKey
 } from "./cli-pq6rte0w.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.28.5",
+  "version": "1.28.6",
   "description": "CLI for Moda - AI agent analytics and observability",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-08-27T02:29:51.059Z",
-  "cli_version": "1.28.5",
+  "bundled_at": "2026-08-28T19:57:51.453Z",
+  "cli_version": "1.28.6",
   "skills": [
     {
       "id": "integration-node-anthropic",