@moda-ai/cli 1.55.50 → 1.55.51

package/dist/{agent-vdqppnq3.js → agent-jyst7r0g.js}

@@ -1,8 +1,8 @@
 import {
   buildDoctorReport
-} from "./cli-73x2yznb.js";
+} from "./cli-3pn6w6m3.js";
 import"./cli-rdh9jjr2.js";
-import"./cli-79pzgqtj.js";
+import"./cli-s3bcce69.js";
 import"./cli-mm48br00.js";
 import {
   readHarnessSyncState
@@ -95,7 +95,7 @@ async function buildAgentContext(context) {
   const graph = readHarnessGraphIfPresent(context.cwd);
   const reportState = readHarnessReportState(context.cwd);
   const syncState = readHarnessSyncState(context.cwd);
-  const harness = graph ? await import("./harness-fx091nmr.js") : undefined;
+  const harness = graph ? await import("./harness-0pzqswvr.js") : undefined;
   const topFindings = doctor.checks.filter((check) => check.status === "fail" || check.status === "warning").slice(0, 12).map(checkToFinding);
   const evidenceRefs = [
     ...doctor.checks.map(checkToEvidenceRef),

package/dist/{cli-73x2yznb.js → cli-3pn6w6m3.js}

@@ -4,7 +4,7 @@ import {
 } from "./cli-rdh9jjr2.js";
 import {
   inspectPromptManifest
-} from "./cli-79pzgqtj.js";
+} from "./cli-s3bcce69.js";
 import {
   readHarnessSyncState,
   renderDoctorHuman,
@@ -395,7 +395,7 @@ async function harnessCurrentCheck(cwd, manifestPath, manifestExists, tenantId)
     };
   }
   try {
-    const { scanHarness } = await import("./harness-fx091nmr.js");
+    const { scanHarness } = await import("./harness-0pzqswvr.js");
     const current = scanHarness({
       rootDir: cwd,
       scannerVersion: "doctor",

package/dist/{cli-n3bjh1pc.js → cli-k6kydtkv.js}

@@ -13554,7 +13554,7 @@ function applyPromptDiscovery(graph, discovery) {
 
 // src/harness-candidate-promotion.ts
 import { readFileSync as readFileSync11 } from "node:fs";
-import { resolve as resolve9 } from "node:path";
+import { extname as extname7, posix, resolve as resolve9 } from "node:path";
 var PROMOTED_CONFIDENCE = {
   high: 0.85,
   medium: 0.6
@@ -13566,7 +13566,6 @@ var JS_ASSIGNMENT_NAME = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=/;
 var JS_PROPERTY_NAME = /^\s*(?:public\s+|readonly\s+)?([A-Za-z_$][\w$]*)\s*:\s*(?:new\s+)?(?:[\w.$]*\.)?(?:tool|functionTool|createTool|dynamicTool|DynamicStructuredTool)\s*\(/;
 var JS_TRAILING_ASSIGNMENT_NAME = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:new\s+)?$/;
 var REGISTRY_CALL_NAME = /\b(?:register_tool|registerTool|add_tool)\s*\(\s*["']?([A-Za-z_$][\w$]*)/;
-var PROMPT_ASSIGNMENT_NAME = /^\s*(?:export\s+)?(?:(?:const|let|var)\s+)?([A-Za-z_$][\w$]*)\s*[:=]/;
 var MODEL_STRING = /["'`]([\w.:/-]*(?:gpt-|o[134](?:-mini)?\b|claude|gemini|llama|mistral|mixtral|deepseek|qwen|grok|sonnet|opus|haiku|command-r|glm|gemma)[\w.:/-]*)["'`]/i;
 function candidateEvidence(candidate) {
   return [{
@@ -13641,17 +13640,786 @@ function promotePromptFileCandidate(candidate, confidence2) {
     evidence: candidateEvidence(candidate)
   };
 }
-function promotePromptLiteralCandidate(candidate, rootDir, confidence2, fileCache) {
+var MODEL_INPUT_KEYS = [
+  "system",
+  "systemPrompt",
+  "system_prompt",
+  "systemMessage",
+  "system_message",
+  "systemInstruction",
+  "system_instruction",
+  "instructions",
+  "prompt",
+  "userPrompt",
+  "user_prompt",
+  "backstory",
+  "content",
+  "input",
+  "template",
+  "text"
+];
+var DIRECT_PROMPT_KEYS = new Set([
+  "system",
+  "systemPrompt",
+  "system_prompt",
+  "systemMessage",
+  "system_message",
+  "systemInstruction",
+  "system_instruction",
+  "instructions",
+  "prompt",
+  "userPrompt",
+  "user_prompt",
+  "backstory",
+  "system_template",
+  "instance_template"
+]);
+var GENERIC_IDENTIFIERS = new Set([
+  "prompt",
+  "template",
+  "system",
+  "instructions",
+  "content",
+  "text",
+  "message",
+  "input",
+  "body",
+  "value"
+]);
+var CONFIG_EXTENSIONS = new Set([".json", ".yaml", ".yml"]);
+var PROMPT_NAMED_IDENTIFIER = /prompt|system|instruction/i;
+var SECOND_PERSON_OPENING = /^\s*(?:\[[A-Z]+:\s*|<\w+>\s*)*(?:you|your)\b/i;
+var MIN_UNNAMED_REFERENCED_PROMPT_CHARS = 200;
+var REFERENCED_PROMPT_CONFIDENCE = 0.7;
+var MIN_RESOLVED_PROMPT_CHARS = 20;
+var MIN_CONFIG_PROMPT_CHARS = 40;
+var MAX_BUILDER_LOOKBEHIND_LINES = 40;
+var DEFINITION_HEAD = /^\s*(?:export\s+)?(?:(?:const|let|var|readonly|static|public|private)\s+)*["']?([A-Za-z_$][\w$]*)["']?\s*(?:(?::\s*[\w$.<>[\]|, ]+?)?\s*(=)(?![=>])|(:))\s*(.*)$/;
+var VALUE_WRAPPERS = /^(?:\(|\[|(?:textwrap\.)?dedent\(|inspect\.cleandoc\(|outdent|stripIndent)\s*/;
+var STRING_OPENER = /^(?:[fFrRbBuU]{1,2})?("""|\'\'\'|"|'|`)/;
+var BUILDER_HEAD = /^\s*(?:export\s+)?(?:async\s+)?(?:function\s+([A-Za-z_$][\w$]*)\s*\(|def\s+([A-Za-z_]\w*)\s*\(|(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>)/;
+var CODE_LIKE_CONTENT = [
+  /^\s*(?:SELECT|WITH|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)\b[\s\S]*\b(?:FROM|INTO|SET|TABLE|AS)\b/i,
+  /^\s*[a-z][\w+.-]*:\/\/\S*$/i,
+  /^\s*(?:<![Dd][Oo][Cc][Tt][Yy][Pp][Ee]\b|<(?:html|head|body|div|span|p|a|ul|ol|li|table|tr|td|th|button|img|svg|path|section|header|footer|nav|main|form|input|label|select|option|textarea|h[1-6]|br|hr|meta|link|script|style|template|iframe|video)[\s/>]|<[A-Z][\w.]*[\s/>]|<[A-Za-z][\w.-]*\s+[\w:-]+=)/
+];
+var INLINE_PROMPT_KEY = new RegExp(`(?<![\\w$.])["']?(${[...new Set([...MODEL_INPUT_KEYS, ...DIRECT_PROMPT_KEYS])].join("|")})["']?\\s*(?::|=(?![=>]))\\s*`, "g");
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readStringLiteral(text, start) {
+  const opener = text.startsWith('"""', start) || text.startsWith("'''", start) ? text.slice(start, start + 3) : text[start];
+  let i = start + opener.length;
+  while (i < text.length) {
+    const char = text[i];
+    if (char === "\\") {
+      i += 2;
+      continue;
+    }
+    if (opener.length === 1 && opener !== "`" && char === `
+`)
+      return;
+    if (opener === "`" && char === "$" && text[i + 1] === "{") {
+      let depth = 1;
+      i += 2;
+      while (i < text.length && depth > 0) {
+        if (text[i] === "`" || text[i] === '"' || text[i] === "'") {
+          const nested = readStringLiteral(text, i);
+          if (nested) {
+            i = nested.end;
+            continue;
+          }
+          if (text[i] === "`")
+            return;
+          i += 1;
+          continue;
+        }
+        const regexEnd = text[i] === "/" ? regexLiteralEnd(text, i) : undefined;
+        if (regexEnd !== undefined) {
+          i = regexEnd;
+          continue;
+        }
+        if (text.startsWith("//", i)) {
+          const newline = text.indexOf(`
+`, i);
+          i = newline < 0 ? text.length : newline;
+          continue;
+        }
+        if (text.startsWith("/*", i)) {
+          const close = text.indexOf("*/", i + 2);
+          if (close < 0)
+            return;
+          i = close + 2;
+          continue;
+        }
+        if (text[i] === "{")
+          depth += 1;
+        else if (text[i] === "}")
+          depth -= 1;
+        i += 1;
+      }
+      continue;
+    }
+    if (text.startsWith(opener, i))
+      return { value: text.slice(start + opener.length, i), end: i + opener.length };
+    i += 1;
+  }
+  return;
+}
+var EXPRESSION_KEYWORDS = new Set([
+  "return",
+  "typeof",
+  "instanceof",
+  "in",
+  "of",
+  "new",
+  "delete",
+  "void",
+  "throw",
+  "case",
+  "do",
+  "else",
+  "yield",
+  "await"
+]);
+function endsWithOperand(text, end) {
+  let i = end;
+  while (i > 0 && /\s/.test(text[i - 1]))
+    i -= 1;
+  if (i === 0)
+    return false;
+  const char = text[i - 1];
+  if (char === ")" || char === "]" || char === '"' || char === "'" || char === "`")
+    return true;
+  if (/[\w$]/.test(char)) {
+    let wordStart = i;
+    while (wordStart > 0 && /[\w$]/.test(text[wordStart - 1]))
+      wordStart -= 1;
+    const word = text.slice(wordStart, i);
+    if (/^\d/.test(word))
+      return true;
+    let before = wordStart;
+    while (before > 0 && /\s/.test(text[before - 1]))
+      before -= 1;
+    const isProperty = text[before - 1] === "." && text[before - 2] !== ".";
+    return isProperty || !EXPRESSION_KEYWORDS.has(word);
+  }
+  if ((char === "+" || char === "-") && text[i - 2] === char)
+    return endsWithOperand(text, i - 2);
+  if (char === "!" && i >= 2 && /[\w$)\]]/.test(text[i - 2]))
+    return endsWithOperand(text, i - 1);
+  return false;
+}
+function regexLiteralEnd(text, start) {
+  if (text[start + 1] === "/" || text[start + 1] === "*")
+    return;
+  if (endsWithOperand(text, start))
+    return;
+  let inClass = false;
+  for (let i = start + 1;i < text.length; i += 1) {
+    const char = text[i];
+    if (char === `
+`)
+      return;
+    if (char === "\\") {
+      i += 1;
+      continue;
+    }
+    if (char === "[")
+      inClass = true;
+    else if (char === "]")
+      inClass = false;
+    else if (char === "/" && !inClass) {
+      let end = i + 1;
+      while (/[a-z]/i.test(text[end] ?? ""))
+        end += 1;
+      return end;
+    }
+  }
+  return;
+}
+function readStringValue(text, offset) {
+  let i = offset;
+  const parts = [];
+  let concatenated = false;
+  let listed = false;
+  for (;; ) {
+    const opener = STRING_OPENER.exec(text.slice(i, i + 5));
+    if (!opener)
+      break;
+    const literal = readStringLiteral(text, i + opener[0].length - opener[1].length);
+    if (!literal)
+      return;
+    parts.push(literal.value);
+    i = literal.end;
+    const separator = /^[\s+,]*/.exec(text.slice(i))[0];
+    if (!STRING_OPENER.test(text.slice(i + separator.length, i + separator.length + 5))) {
+      if (separator.includes("+"))
+        return;
+      break;
+    }
+    if (separator.includes("+") && separator.includes(","))
+      return;
+    if (separator.includes(","))
+      listed = true;
+    else
+      concatenated = true;
+    i += separator.length;
+  }
+  if (parts.length === 0 || concatenated && listed)
+    return;
+  if (!listed)
+    return parts.join("");
+  const join9 = /^[\s,]*\]\s*\.join\(\s*(["'`])((?:\\.|(?!\1).)*)\1\s*\)/.exec(text.slice(i));
+  const joinSeparator = join9 ? join9[2].replace(/\\n/g, `
+`).replace(/\\t/g, "\t") : `
+`;
+  return parts.join(joinSeparator);
+}
+function textOffsetOfLine(lines, index) {
+  let offset = 0;
+  for (let i = 0;i < index; i += 1)
+    offset += lines[i].length + 1;
+  return offset;
+}
+function stringStart(rest) {
+  let consumed = 0;
+  let remaining = rest;
+  for (let guard = 0;guard < 3; guard += 1) {
+    const wrapper = VALUE_WRAPPERS.exec(remaining);
+    if (!wrapper)
+      break;
+    consumed += wrapper[0].length;
+    remaining = remaining.slice(wrapper[0].length);
+  }
+  return STRING_OPENER.test(remaining) ? consumed : -1;
+}
+function resolvePromptLiteralDefinition(lines, startLine) {
+  const text = lines.join(`
+`);
+  for (const index of [startLine - 1, startLine - 2]) {
+    const line2 = lines[index];
+    if (line2 === undefined)
+      continue;
+    const head = DEFINITION_HEAD.exec(line2);
+    if (head) {
+      const [, name, , colon, rest] = head;
+      let valueOffset = -1;
+      const inline = stringStart(rest);
+      if (inline >= 0) {
+        valueOffset = textOffsetOfLine(lines, index) + line2.length - rest.length + inline;
+      } else if (/^(?:\(|\[|(?:textwrap\.)?dedent\(|)\s*$/.test(rest) && lines[index + 1] !== undefined) {
+        const next = lines[index + 1];
+        const nextStart = stringStart(next.trimStart());
+        if (nextStart >= 0)
+          valueOffset = textOffsetOfLine(lines, index + 1) + (next.length - next.trimStart().length) + nextStart;
+      }
+      if (valueOffset < 0 && colon) {
+        const block = readYamlBlockScalar(lines, index, rest);
+        if (block !== undefined)
+          return { key: name, text: block, line: index + 1 };
+      }
+      if (valueOffset < 0)
+        continue;
+      let offset2 = valueOffset;
+      while (!STRING_OPENER.test(text.slice(offset2, offset2 + 5)))
+        offset2 += 1;
+      const value2 = readStringValue(text, offset2);
+      if (value2 === undefined)
+        continue;
+      return colon ? { key: name, text: value2, line: index + 1 } : { identifier: name, text: value2, line: index + 1 };
+    }
+    if (index !== startLine - 1)
+      continue;
+    const returned = /^\s*return\s+(.*)$/.exec(line2);
+    if (!returned)
+      continue;
+    const start = stringStart(returned[1]);
+    if (start < 0)
+      continue;
+    let offset = textOffsetOfLine(lines, index) + line2.length - returned[1].length + start;
+    while (!STRING_OPENER.test(text.slice(offset, offset + 5)))
+      offset += 1;
+    const value = readStringValue(text, offset);
+    if (value === undefined)
+      continue;
+    for (let i = index - 1;i >= Math.max(0, index - MAX_BUILDER_LOOKBEHIND_LINES); i -= 1) {
+      const builder = BUILDER_HEAD.exec(lines[i]);
+      if (builder)
+        return { identifier: builder[1] ?? builder[2] ?? builder[3], text: value, line: index + 1 };
+    }
+  }
+  const line = lines[startLine - 1];
+  if (line === undefined)
+    return;
+  if (/^\s*(?:\/\/|\*(?!\/)|#)/.test(line))
+    return;
+  for (const match of line.matchAll(INLINE_PROMPT_KEY)) {
+    if (endsInComment(line.slice(0, match.index)))
+      break;
+    const after = match.index + match[0].length;
+    const start = stringStart(line.slice(after));
+    if (start < 0)
+      continue;
+    let offset = textOffsetOfLine(lines, startLine - 1) + after + start;
+    while (!STRING_OPENER.test(text.slice(offset, offset + 5)))
+      offset += 1;
+    const value = readStringValue(text, offset);
+    if (value !== undefined)
+      return { key: match[1], text: value, line: startLine };
+  }
+  return;
+}
+function endsInComment(prefix) {
+  let quote;
+  let inBlock = false;
+  for (let i = 0;i < prefix.length; i += 1) {
+    const char = prefix[i];
+    if (inBlock) {
+      if (prefix.startsWith("*/", i)) {
+        inBlock = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (char === "\\")
+        i += 1;
+      else if (char === quote)
+        quote = undefined;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    const regexEnd = char === "/" ? regexLiteralEnd(prefix, i) : undefined;
+    if (regexEnd !== undefined) {
+      i = regexEnd - 1;
+      continue;
+    }
+    if (prefix.startsWith("//", i))
+      return true;
+    else if (prefix.startsWith("/*", i)) {
+      inBlock = true;
+      i += 1;
+    }
+  }
+  return inBlock;
+}
+function readYamlBlockScalar(lines, index, rest) {
+  const indicator = /^([|>])([-+]?)\s*(?:#.*)?$/.exec(rest.trim());
+  if (!indicator)
+    return;
+  const [, style, chomping] = indicator;
+  const keyIndent = lines[index].length - lines[index].trimStart().length;
+  const body = [];
+  let blockIndent;
+  for (let i = index + 1;i < lines.length; i += 1) {
+    const line = lines[i];
+    if (!line.trim()) {
+      body.push("");
+      continue;
+    }
+    const indent = line.length - line.trimStart().length;
+    if (indent <= keyIndent)
+      break;
+    blockIndent ??= indent;
+    if (indent < blockIndent)
+      break;
+    body.push(line.slice(blockIndent));
+  }
+  let trailingBlank = 0;
+  while (body.length > 0 && body[body.length - 1] === "") {
+    body.pop();
+    trailingBlank += 1;
+  }
+  if (body.length === 0)
+    return;
+  let text;
+  if (style === "|") {
+    text = body.join(`
+`);
+  } else {
+    if (body.some((line) => /^\s/.test(line)))
+      return;
+    text = "";
+    let blanks = 0;
+    for (const [i, line] of body.entries()) {
+      if (line === "") {
+        blanks += 1;
+        continue;
+      }
+      text += i === 0 || text === "" ? `
+`.repeat(blanks) + line : blanks > 0 ? `
+`.repeat(blanks) + line : ` ${line}`;
+      blanks = 0;
+    }
+  }
+  if (chomping === "-")
+    return text;
+  return chomping === "+" ? text + `
+`.repeat(trailingBlank + 1) : `${text}
+`;
+}
+function isCodeLikeContent(text) {
+  return CODE_LIKE_CONTENT.some((pattern) => pattern.test(text));
+}
+var SOURCE_EXTENSION = /\.(?:[cm]?[jt]sx?|py)$/;
+function moduleStems(definitionPath) {
+  const stem = definitionPath.replace(/\.[^./]+$/, "");
+  const dir = /\/(?:index|__init__)$/.test(stem) ? stem.replace(/\/[^/]+$/, "") : undefined;
+  return dir ? [stem, dir] : [stem];
+}
+function specifierResolvesTo(spec, importerPath, definitionPath, python) {
+  const stems = moduleStems(definitionPath);
+  const importerDir = posix.dirname(importerPath);
+  let target;
+  let exact = true;
+  if (python) {
+    const dots = /^\.*/.exec(spec)[0].length;
+    const rest = spec.slice(dots).split(".").filter(Boolean).join("/");
+    if (dots > 0) {
+      let base = importerDir;
+      for (let i = 1;i < dots; i += 1)
+        base = posix.dirname(base);
+      target = posix.normalize(posix.join(base, rest));
+    } else if (!rest.includes("/")) {
+      return stems.some((stem) => stem === rest || stem === posix.join(importerDir, rest));
+    } else {
+      target = rest;
+      exact = false;
+    }
+  } else if (spec.startsWith(".")) {
+    target = posix.normalize(posix.join(importerDir, spec)).replace(SOURCE_EXTENSION, "");
+  } else {
+    const segments = spec.replace(SOURCE_EXTENSION, "").split("/");
+    if (segments.length > 0 && /^[@~#$]/.test(segments[0]))
+      segments.shift();
+    if (segments.length < 2)
+      return false;
+    target = segments.join("/");
+    exact = false;
+  }
+  return stems.some((stem) => stem === target || !exact && stem.endsWith(`/${target}`));
+}
+function localNameIn(specifiers, identifier) {
+  for (const raw of specifiers.replace(/#[^\n]*|\/\/[^\n]*/g, "").replace(/[()]/g, "").split(",")) {
+    const match = /^\s*(?:type\s+)?([A-Za-z_$][\w$]*)(?:\s*(?:\bas\b|:)\s*([A-Za-z_$][\w$]*))?\s*$/.exec(raw);
+    if (match?.[1] === identifier)
+      return match[2] ?? identifier;
+  }
+  return;
+}
+function importedLocalName(importerPath, lines, identifier, definitionPath, exportsDefault = false) {
+  const text = lines.join(`
+`);
+  const python = extname7(importerPath) === ".py";
+  if (python) {
+    for (const match of text.matchAll(/^[ \t]*from\s+([.\w]+)\s+import\s+(\([^)]*\)|[^\n]*)/gm)) {
+      if (!specifierResolvesTo(match[1], importerPath, definitionPath, true))
+        continue;
+      const local = localNameIn(match[2].replace(/\\\n/g, " "), identifier);
+      if (local)
+        return local;
+    }
+    for (const match of text.matchAll(/^[ \t]*import\s+([.\w]+)(?:\s+as\s+(\w+))?/gm)) {
+      if (specifierResolvesTo(match[1], importerPath, definitionPath, true))
+        return identifier;
+    }
+    return;
+  }
+  const statements = [
+    /\bimport\s+(?:type\s+)?(?:[A-Za-z_$][\w$]*\s*,\s*)?\{([^}]*)\}\s*from\s*["']([^"']+)["']/g,
+    /\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*(?:await\s+)?(?:require|import)\(\s*["']([^"']+)["']\s*\)/g
+  ];
+  for (const pattern of statements) {
+    for (const match of text.matchAll(pattern)) {
+      if (!specifierResolvesTo(match[2], importerPath, definitionPath, false))
+        continue;
+      const local = localNameIn(match[1], identifier);
+      if (local)
+        return local;
+    }
+  }
+  if (exportsDefault) {
+    for (const match of text.matchAll(/\bimport\s+(?:type\s+)?([A-Za-z_$][\w$]*)\s*(?:,\s*(?:\{[^}]*\}|\*\s*as\s+[A-Za-z_$][\w$]*)\s*)?from\s*["']([^"']+)["']/g)) {
+      if (specifierResolvesTo(match[2], importerPath, definitionPath, false))
+        return match[1];
+    }
+  }
+  for (const match of text.matchAll(/\bimport\s*\*\s*as\s+[A-Za-z_$][\w$]*\s+from\s*["']([^"']+)["']/g)) {
+    if (specifierResolvesTo(match[1], importerPath, definitionPath, false))
+      return identifier;
+  }
+  return;
+}
+function importStatementLines(lines) {
+  const text = lines.join(`
+`);
+  const covered = new Set;
+  const statement = /^[ \t]*(?:import\b[^;]*?\bfrom\s*["'][^"'\n]+["']|export\s*(?:type\s*)?\{[^}]*\}\s*from\s*["'][^"'\n]+["']|from\s+[.\w]+\s+import\s*(?:\([^)]*\)|[^\n]*))/gm;
+  for (const match of text.matchAll(statement)) {
+    const first2 = text.slice(0, match.index).split(`
+`).length - 1;
+    const last = first2 + match[0].split(`
+`).length - 1;
+    for (let i = first2;i <= last; i += 1)
+      covered.add(i);
+  }
+  return covered;
+}
+var MODEL_CALLEE = /model|llm|complet|generat|chat|invoke|infer|prompt|agent|judge|claude|gpt|openai|anthropic|gemini|\.create$/i;
+function calleeImportedFromModelFile(callee, path, lines, modelFiles) {
+  const base = callee.split(".")[0];
+  const text = lines.join(`
+`);
+  const python = extname7(path) === ".py";
+  const statements = python ? [/^[ \t]*from\s+([.\w]+)\s+import\s+(\([^)]*\)|[^\n]*)/gm] : [
+    /\bimport\s+(?:type\s+)?(?:([A-Za-z_$][\w$]*)\s*,?\s*)?(?:\{([^}]*)\}|\*\s*as\s+([A-Za-z_$][\w$]*))?\s*from\s*["']([^"']+)["']/g,
+    /\b(?:const|let|var)\s*\{([^}]*)\}\s*=\s*(?:await\s+)?(?:require|import)\(\s*["']([^"']+)["']\s*\)/g
+  ];
+  for (const pattern of statements) {
+    for (const match of text.matchAll(pattern)) {
+      let spec;
+      let names;
+      if (python) {
+        spec = match[1];
+        names = match[2].replace(/[()]/g, "").split(",").map((part) => part.trim().split(/\s+as\s+/).pop() ?? "");
+      } else if (match.length === 5) {
+        spec = match[4];
+        names = [match[1] ?? "", match[3] ?? "", ...(match[2] ?? "").split(",").map((part) => part.trim().split(/\s+as\s+/).pop() ?? "")];
+      } else {
+        spec = match[2];
+        names = match[1].split(",").map((part) => part.trim().split(/\s*:\s*/).pop() ?? "");
+      }
+      if (!names.includes(base))
+        continue;
+      for (const modelPath of modelFiles) {
+        if (specifierResolvesTo(spec, path, modelPath, python))
+          return true;
+      }
+    }
+  }
+  return false;
+}
+var INSTRUCTION_KEY = /\b(instruction|instructions|task|brief|goal|message|query|question)["']?\s*[:=]\s*$/;
+var MODEL_CALL_IN_BODY = /\b[\w$.]*(?:model|llm|complet|generat|chat|claude|gpt|openai|anthropic|gemini)[\w$]*\s*\(|\brole\b\s*["']?\s*[:=]\s*["'](?:system|user|assistant)["']/i;
+var MAX_HELPER_BODY_LINES = 80;
+var MAX_CALL_CONTEXT_LINES = 25;
+var CALL_ROLE_WINDOW_LINES = 8;
+function localHelperCallsModel(callee, lines) {
+  const ident = escapeRegExp(callee.split(".").pop() ?? callee);
+  const head = new RegExp(`^\\s*(?:export\\s+)?(?:async\\s+)?(?:function\\s+${ident}\\s*[(<]|def\\s+${ident}\\s*\\(|(?:const|let|var)\\s+${ident}\\s*=\\s*(?:async\\s+)?(?:\\(|[A-Za-z_$][\\w$]*\\s*=>)|(?:(?:private|public|protected|static|async)\\s+)*${ident}\\s*\\([^)]*\\)?\\s*[:{])`);
+  const start = lines.findIndex((line) => head.test(line));
+  if (start < 0)
+    return false;
+  return lines.slice(start + 1, start + 1 + MAX_HELPER_BODY_LINES).some((line) => MODEL_CALL_IN_BODY.test(line));
+}
+function callCarriesChatMessages(lines, index) {
+  for (let i = Math.max(0, index - CALL_ROLE_WINDOW_LINES);i < Math.min(lines.length, index + CALL_ROLE_WINDOW_LINES + 1); i += 1) {
+    if (/\brole\b\s*["']?\s*[:=]\s*["'](?:system|user|human|assistant)["']/.test(lines[i]))
+      return true;
+  }
+  return false;
+}
+function composingPromptName(lines, index, identifier) {
+  for (let i = index;i >= Math.max(0, index - MAX_BUILDER_LOOKBEHIND_LINES); i -= 1) {
+    const builder = BUILDER_HEAD.exec(lines[i]);
+    const assignment = /^\s*(?:export\s+)?(?:(?:const|let|var)\s+)?([A-Za-z_$][\w$]*)\s*(?::[^=]+)?=(?![=>])/.exec(lines[i]);
+    const name = builder ? builder[1] ?? builder[2] ?? builder[3] : assignment?.[1];
+    if (name)
+      return name !== identifier && PROMPT_NAMED_IDENTIFIER.test(name) ? name : undefined;
+  }
+  return;
+}
+var OUTPUT_CALLEE = /^(?:console\.\w+|(?:[\w$]+\.)*(?:log|logger|logging)\.\w+|print|log|alert|toast(?:\.\w+)?|(?:[\w$]+\.)*(?:write|writeFile|writeFileSync|appendFile|send|json|setState|set[A-Z]\w*))$/;
+function enclosingCallee(text, index) {
+  let depth = 0;
+  for (let i = index - 1;i >= 0; i -= 1) {
+    const char = text[i];
+    if (char === ")" || char === "]" || char === "}")
+      depth += 1;
+    else if (char === "[" || char === "{")
+      depth = Math.max(0, depth - 1);
+    else if (char === "(") {
+      if (depth > 0) {
+        depth -= 1;
+        continue;
+      }
+      return /([A-Za-z_$][\w$.]*)\s*$/.exec(text.slice(Math.max(0, i - 200), i))?.[1];
+    }
+  }
+  return;
+}
+function findModelInputUse(identifier, definition, files, rootDir, fileCache, options) {
+  const scan = (path, lines, name) => {
+    const ident = escapeRegExp(name);
+    const keyed = new RegExp(`\\b(${MODEL_INPUT_KEYS.join("|")})["']?\\s*[:=]\\s*(?:await\\s+)?(?:(?:this|self)\\.)?(?:[A-Za-z_$][\\w$]*\\.)?${ident}\\b`);
+    const messageCtor = new RegExp(`\\b(SystemMessage|HumanMessage|SystemMessagePromptTemplate\\.from_template|HumanMessagePromptTemplate\\.from_template|PromptTemplate\\.from_template|ChatPromptTemplate\\.from_template)\\s*\\(\\s*(?:content\\s*=\\s*)?${ident}\\b`);
+    const roleTuple = new RegExp(`\\(\\s*["'](system|user|human)["']\\s*,\\s*${ident}\\b`);
+    const interpolated = new RegExp(`\\b(${MODEL_INPUT_KEYS.join("|")})["']?\\s*[:=]\\s*[fF]?[\`"'][^\`"']*(?:\\$\\{|\\{)${ident}\\b`);
+    const shorthand = DIRECT_PROMPT_KEYS.has(name) ? new RegExp(`[{,(]\\s*${ident}\\s*[,})]`) : undefined;
+    const isModelFile = files.model.has(path);
+    for (let i = 0;i < lines.length; i += 1) {
+      if (path === definition.path && i === definition.line - 1)
+        continue;
+      const line = lines[i];
+      if (line.length > 4000 || !line.includes(name))
+        continue;
+      const fixed = messageCtor.exec(line) ?? roleTuple.exec(line);
+      if (fixed)
+        return { path, line: i + 1, key: fixed[1] };
+      const match = keyed.exec(line) ?? interpolated.exec(line);
+      if (match && (isModelFile || DIRECT_PROMPT_KEYS.has(match[1]) || match[1] === "content" && hasNearbyRole(lines, i + 1))) {
+        return { path, line: i + 1, key: match[1] };
+      }
+      if (shorthand?.test(line) && isModelFile)
+        return { path, line: i + 1, key: name };
+    }
+    return;
+  };
+  const firstReference = (path, lines, name) => {
+    const ident = escapeRegExp(name);
+    const reference = new RegExp(`(?<![\\w$])(?:(?:this|self|[A-Za-z_$][\\w$]*)\\.)?${ident}(?![\\w$])`, "g");
+    const jsxAttribute = new RegExp(`[\\w-]+=\\{\\s*${ident}\\s*\\}`);
+    const jsxChild = /\.[jt]sx$/.test(path) ? new RegExp(`(?<!\\$)\\{\\s*${ident}\\s*\\}`) : undefined;
+    const imports = importStatementLines(lines);
+    const isModelFile = files.model.has(path);
+    const declaration = new RegExp(`^\\s*(?:export\\s+)?(?:default\\s+)?(?:async\\s+)?(?:function\\s*\\*?\\s*|def\\s+|(?:const|let|var)\\s+)${ident}\\b`);
+    for (let i = 0;i < lines.length; i += 1) {
+      if (path === definition.path && i === definition.line - 1)
+        continue;
+      const line = lines[i];
+      if (line.length > 4000 || !line.includes(name))
+        continue;
+      if (/^\s*(?:\/\/|#|\*|import\b|export\s*\{|from\s+\S+\s+import\b)/.test(line) || jsxAttribute.test(line) || jsxChild?.test(line))
+        continue;
+      const context = `${lines.slice(Math.max(0, i - MAX_CALL_CONTEXT_LINES), i).join(`
+`)}
+`;
+      if (declaration.test(line) || imports.has(i))
+        continue;
+      for (const match of line.matchAll(reference)) {
+        const callee = enclosingCallee(context + line, context.length + match.index);
+        if (callee && OUTPUT_CALLEE.test(callee))
+          continue;
+        const before = (context + line).slice(0, context.length + match.index);
+        const instructionKey = INSTRUCTION_KEY.exec(before)?.[1];
+        const after = line.slice(match.index + match[0].length);
+        const composed = /(?:\$\{\s*|\+\s*|[[,]\s*|^\s*|[^=!<>]=\s*|\breturn\s+|\bawait\s+)$/.test(before) && /^\s*(?:\}|\+|,|\]|;|\(|$)/.test(after);
+        const composedInto = composed ? composingPromptName(lines, i, name) : undefined;
+        const via = isModelFile ? "a file that calls a model" : instructionKey ? `the ${instructionKey} key of an agent call` : callee && MODEL_CALLEE.test(callee) ? `the model-call helper ${callee}` : callee && localHelperCallsModel(callee, lines) ? `the local helper ${callee}, which calls a model` : callee && calleeImportedFromModelFile(callee, path, lines, files.model) ? `${callee}, imported from a module that calls a model` : callee && callCarriesChatMessages(lines, i) ? `a ${callee} call that also carries chat messages` : composedInto && `composition into ${composedInto}`;
+        if (via)
+          return { path, line: i + 1, key: "reference", referenceOnly: true, via };
+      }
+    }
+    return;
+  };
+  const own = readFileLines(rootDir, definition.path, fileCache);
+  const local = own ? scan(definition.path, own, identifier) : undefined;
+  if (local)
+    return local;
+  const importers = [];
+  if (!GENERIC_IDENTIFIERS.has(identifier)) {
+    const ident = escapeRegExp(identifier);
+    const exportsDefault = own?.some((line) => new RegExp(`^\\s*export\\s+default\\s+${ident}\\s*;?\\s*$|\\bexport\\s*\\{[^}]*\\b${ident}\\s+as\\s+default\\b`).test(line)) ?? false;
+    const moduleName = posix.basename(definition.path).replace(/\.[^.]+$/, "");
+    for (const path of files.searchable) {
+      if (path === definition.path)
+        continue;
+      const lines = readFileLines(rootDir, path, fileCache);
+      if (!lines || !lines.some((line) => line.includes(identifier) || exportsDefault && line.includes(moduleName)))
+        continue;
+      const name = importedLocalName(path, lines, identifier, definition.path, exportsDefault);
+      if (!name)
+        continue;
+      const use = scan(path, lines, name);
+      if (use)
+        return use;
+      importers.push({ path, lines, name });
+    }
+  }
+  if (!options.allowReference)
+    return;
+  if (own) {
+    const use = firstReference(definition.path, own, identifier);
+    if (use)
+      return use;
+  }
+  for (const importer of importers) {
+    const use = firstReference(importer.path, importer.lines, importer.name);
+    if (use)
+      return use;
+  }
+  return;
+}
+function readsAsInstructions(identifier, text) {
+  const score = instructionScore(text);
+  const secondPerson = SECOND_PERSON_OPENING.test(text);
+  if (PROMPT_NAMED_IDENTIFIER.test(identifier))
+    return score >= 2 || secondPerson;
+  return secondPerson && score >= 2 && text.length >= MIN_UNNAMED_REFERENCED_PROMPT_CHARS;
+}
+function hasNearbyRole(lines, line) {
+  for (let i = Math.max(0, line - 4);i < Math.min(lines.length, line + 3); i += 1) {
+    if (/\brole\b\s*["']?\s*[:=]/.test(lines[i]))
+      return true;
+  }
+  return false;
+}
+function isDirectModelInput(key, value, path, lines, line, modelFiles) {
+  if (CONFIG_EXTENSIONS.has(extname7(path).toLowerCase())) {
+    return DIRECT_PROMPT_KEYS.has(key) && value.length >= MIN_CONFIG_PROMPT_CHARS;
+  }
+  if (modelFiles.has(path)) {
+    return DIRECT_PROMPT_KEYS.has(key) || key === "content" && hasNearbyRole(lines, line);
+  }
+  return DIRECT_PROMPT_KEYS.has(key) && instructionScore(value) >= 2;
+}
+function promotePromptLiteralCandidate(candidate, rootDir, confidence2, fileCache, files) {
   const lines = readFileLines(rootDir, candidate.path, fileCache);
-  const assignedName = lines ? PROMPT_ASSIGNMENT_NAME.exec(lines[candidate.startLine - 1] ?? "")?.[1] ?? (candidate.startLine >= 2 ? PROMPT_ASSIGNMENT_NAME.exec(lines[candidate.startLine - 2] ?? "")?.[1] : undefined) : undefined;
+  if (!lines)
+    return;
+  const definition = resolvePromptLiteralDefinition(lines, candidate.startLine);
+  if (!definition)
+    return;
+  const value = definition.text.trim();
+  const literalText = value.replace(/\$\{[^}]*\}|\{[A-Za-z_][\w.]*\}/g, "").trim();
+  if (literalText.length < MIN_RESOLVED_PROMPT_CHARS || isCodeLikeContent(value))
+    return;
+  const key = definition.key ?? (definition.identifier && DIRECT_PROMPT_KEYS.has(definition.identifier) ? definition.identifier : undefined);
+  let use;
+  if (key && isDirectModelInput(key, value, candidate.path, lines, definition.line, files.model)) {
+    use = { path: candidate.path, line: definition.line, key };
+  }
+  if (!use && definition.identifier) {
+    use = findModelInputUse(definition.identifier, { path: candidate.path, line: definition.line }, files, rootDir, fileCache, {
+      allowReference: readsAsInstructions(definition.identifier, value)
+    });
+  }
+  if (!use)
+    return;
+  const name = definition.identifier ?? definition.key;
+  const evidence = [{ path: candidate.path, line: definition.line, reason: `deterministic detector ${candidate.signal}` }];
+  const sameSite = use.path === candidate.path && use.line === definition.line;
+  if (!sameSite) {
+    evidence.push({
+      path: use.path,
+      line: use.line,
+      reason: use.referenceOnly ? "prompt-named literal referenced here (positional or composed model input)" : `passed to a model call as ${use.key}`
+    });
+  }
   return {
-    id: stableId("prompt", `${pathStem(candidate.path)}:L${candidate.startLine}`),
+    id: stableId("prompt", `${pathStem(candidate.path)}:L${definition.line}`),
     type: "prompt",
-    name: assignedName ? titleFromId(assignedName) : `Inline Prompt (${candidate.path}:${candidate.startLine})`,
+    name: name ? titleFromId(name) : `Inline Prompt (${candidate.path}:${definition.line})`,
     scope: "shared",
     usedByAgentIds: [],
-    confidence: confidence2,
-    evidence: candidateEvidence(candidate)
+    confidence: use.referenceOnly ? Math.min(confidence2, REFERENCED_PROMPT_CONFIDENCE) : confidence2,
+    confidenceReason: use.referenceOnly ? `Deterministic: instruction-like literal ${name} is referenced at ${use.path}:${use.line} through ${use.via}, but no prompt key (system, instructions, content) was found at the call.` : sameSite ? `Deterministic: string literal written under the ${use.key} key at ${candidate.path}:${definition.line}.` : `Deterministic: string literal ${name} passed to a model call as ${use.key} at ${use.path}:${use.line}.`,
+    evidence,
+    body: definition.text
   };
 }
 function promoteModelConfigCandidate(candidate, rootDir, confidence2, fileCache) {
@@ -13683,6 +14451,10 @@ function mergePromotedDuplicate(existing, next) {
 function promoteHarnessCandidates(report, rootDir) {
   const fileCache = new Map;
   const byId = new Map;
+  const files = {
+    model: new Set(report.candidates.filter((candidate) => candidate.kind === "llm_call_site" || candidate.kind === "framework_construct").map((candidate) => candidate.path)),
+    searchable: new Set(report.files.map((file) => file.path))
+  };
   for (const candidate of report.candidates) {
     const confidence2 = PROMOTED_CONFIDENCE[candidate.confidence];
     if (confidence2 === undefined)
@@ -13697,7 +14469,7 @@ function promoteHarnessCandidates(report, rootDir) {
         break;
       case "prompt_literal":
         if (candidate.confidence === "high") {
-          artifact = promotePromptLiteralCandidate(candidate, rootDir, confidence2, fileCache);
+          artifact = promotePromptLiteralCandidate(candidate, rootDir, confidence2, fileCache, files);
         }
         break;
       case "model_config":
@@ -14049,7 +14821,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-jfbcsx2s.js");
+        const { runGithubActionsAnalyze } = await import("./harness-github-actions-nzcpftjn.js");
         const result = await runGithubActionsAnalyze(rootDir, {
           writeReport: (report2) => {
             const normalized = normalizeHarnessReport(report2);
@@ -14656,7 +15428,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]);
@@ -15064,7 +15836,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;
@@ -15818,6 +16590,7 @@ function renderExternalHarnessAnalystPrompt(options) {
     "- unknowns: report-level open questions with id, question, and citationIds",
     "",
     'Use exact field names and numeric confidence values from 0 to 1. Do not write string confidence values like "high". Do not use confidence >= 0.90 unless the claim is direct evidence from the cited line(s).',
+    'Every graph item with confidence below 0.85 must also carry confidenceReason: one sentence naming what held confidence down, e.g. "Inferred from AGENTS.md:231-232 only; no source file defines this agent." or "Entrypoint read, but the tool registry was outside the snapshot."',
     "Each graph item with evidence must use evidence: [{ path, reason }], not citationIds/citations.",
     ...spec ? spec.contractLines : [
       'Runtime agents must include id, name, kind:"runtime_agent", root, entrypointIds, channelAdapterIds, artifactIds, identityNamespaceIds, deploymentIds, frameworkIds, modelProviderIds, confidence, evidence.',

package/dist/{cli-79pzgqtj.js → cli-s3bcce69.js}

@@ -5768,7 +5768,7 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
   const analyzedDefinitions = new Map;
   if (flags["no-analyze"] !== "true") {
     options.onProgress?.("Analyzing prompt sources before sync.");
-    const { analyzeHarnessPrompts } = await import("./harness-fx091nmr.js");
+    const { analyzeHarnessPrompts } = await import("./harness-0pzqswvr.js");
     const result = await analyzeHarnessPrompts({
       rootDir: process.cwd(),
       existing: established.flatMap((prompt) => prompt.sourceDefinition ? [prompt.sourceDefinition.source] : []),
@@ -5796,7 +5796,7 @@ async function runPromptSyncExclusive(flags, profileOptions, options) {
   const mergedSources = mergePromptSources(manifest.sources, extraSources);
   const manifestUpdate = stableJson(mergedSources) === stableJson(mergePromptSources(manifest.sources, [])) ? undefined : $stringify({ version: 2, prompt_paths: manifest.promptPaths, sources: mergedSources });
   const prompts = await discoverPrompts(extraSources);
-  const { checkPromptAttribution } = await import("./prompt-attribution-avvkfq8c.js");
+  const { checkPromptAttribution } = await import("./prompt-attribution-dfj7etks.js");
   const attribution = checkPromptAttribution(process.cwd(), prompts.map((prompt) => prompt.key));
   const brokenAttribution = attribution.references.filter((reference) => reference.status === "missing");
   if (brokenAttribution.length) {
@@ -6102,7 +6102,7 @@ async function migratePromptManifest(options = {}) {
   let addedSources = [];
   let pendingSources = [];
   if (options.discover) {
-    const { analyzeHarnessPrompts } = await import("./harness-fx091nmr.js");
+    const { analyzeHarnessPrompts } = await import("./harness-0pzqswvr.js");
     const result = await analyzeHarnessPrompts({
       rootDir: root,
       existing: manifest.sources,

package/dist/cli.js

@@ -2967,25 +2967,25 @@ function leafManifestFields(leaf, commands) {
 import { fileURLToPath } from "url";
 import { realpathSync } from "fs";
 async function runPromptsCommand(...args) {
-  return (await import("./prompts-hcecy2na.js")).runPromptsCommand(...args);
+  return (await import("./prompts-r7kzdnca.js")).runPromptsCommand(...args);
 }
 async function runSkillsCommand(...args) {
   return (await import("./skills-mwftqzyk.js")).runSkillsCommand(...args);
 }
 async function runHarnessCommand(...args) {
-  return (await import("./harness-fx091nmr.js")).runHarnessCommand(...args);
+  return (await import("./harness-0pzqswvr.js")).runHarnessCommand(...args);
 }
 async function runSyncCommand(...args) {
-  return (await import("./sync-v0me021f.js")).runSyncCommand(...args);
+  return (await import("./sync-xcjye7em.js")).runSyncCommand(...args);
 }
 async function runRegistryCommand(...args) {
   return (await import("./registry-tv8fktxc.js")).runRegistryCommand(...args);
 }
 async function runDoctorCommand(...args) {
-  return (await import("./doctor-dz8gfz2h.js")).runDoctorCommand(...args);
+  return (await import("./doctor-0z5k6z9a.js")).runDoctorCommand(...args);
 }
 async function runStatusCommand(...args) {
-  return (await import("./doctor-dz8gfz2h.js")).runStatusCommand(...args);
+  return (await import("./doctor-0z5k6z9a.js")).runStatusCommand(...args);
 }
 async function runAuthCommand(...args) {
   return (await import("./profile-commands-nbaec4y9.js")).runAuthCommand(...args);
@@ -2997,7 +2997,7 @@ async function runProfilesCommand(...args) {
   return (await import("./profile-commands-nbaec4y9.js")).runProfilesCommand(...args);
 }
 async function runAgentCommand(...args) {
-  return (await import("./agent-vdqppnq3.js")).runAgentCommand(...args);
+  return (await import("./agent-jyst7r0g.js")).runAgentCommand(...args);
 }
 async function runProductionCommand(...args) {
   return (await import("./production-intelligence-zek0rkzj.js")).runProductionCommand(...args);
@@ -6761,7 +6761,7 @@ var commandRegistry = createCommandRegistry([
     resetApiRequestCountBeforeRun: true,
     telemetry: "result-and-error",
     handler: async (context) => {
-      const { runInit } = await import("./index-q2d1fva7.js");
+      const { runInit } = await import("./index-2p6x0xg2.js");
       if (context.outputMode === "agent-stream") {
         context.output.writeEvent({
           event: "started",

package/dist/{doctor-dz8gfz2h.js → doctor-0z5k6z9a.js}

@@ -3,9 +3,9 @@ import {
   promptsDiscoveredCheck,
   runDoctorCommand,
   runStatusCommand
-} from "./cli-73x2yznb.js";
+} from "./cli-3pn6w6m3.js";
 import"./cli-rdh9jjr2.js";
-import"./cli-79pzgqtj.js";
+import"./cli-s3bcce69.js";
 import"./cli-mm48br00.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/dist/{harness-fx091nmr.js → harness-0pzqswvr.js}

@@ -41,7 +41,7 @@ import {
   writeHarnessAnalyzeResult,
   writeHarnessArtifacts,
   writeHumanProgress
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import"./cli-97fnztpy.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/dist/{harness-github-actions-jfbcsx2s.js → harness-github-actions-nzcpftjn.js}

@@ -1,6 +1,6 @@
 import {
   buildSourceSnapshot
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import"./cli-97fnztpy.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/dist/{index-q2d1fva7.js → index-2p6x0xg2.js}

@@ -21,7 +21,7 @@ import {
 } from "./cli-hcwdz9sd.js";
 import {
   buildDoctorReport
-} from "./cli-73x2yznb.js";
+} from "./cli-3pn6w6m3.js";
 import {
   ConnectCodeError,
   connectWithCode,
@@ -32,7 +32,7 @@ import {
 import {
   initPrompts,
   runPromptSync
-} from "./cli-79pzgqtj.js";
+} from "./cli-s3bcce69.js";
 import"./cli-mm48br00.js";
 import {
   codingAgentDisplayName,
@@ -46,7 +46,7 @@ import {
   runCodingAgent,
   runHarnessCommand,
   startRemoteAnalyze
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import {
   stripAnsi
 } from "./cli-97fnztpy.js";

package/dist/{prompt-attribution-avvkfq8c.js → prompt-attribution-dfj7etks.js}

@@ -1,7 +1,7 @@
 import {
   inventoryFiles,
   safePromptEvidencePath
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import"./cli-97fnztpy.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/dist/prompt-source-mcp.js

@@ -3,7 +3,7 @@ import {
   checkPromptMapping,
   discoverHarnessPromptSources,
   safePromptEvidencePath
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import"./cli-97fnztpy.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/dist/{prompts-hcecy2na.js → prompts-r7kzdnca.js}

@@ -9,7 +9,7 @@ import {
   runPromptSync,
   runPromptsCommand,
   writePromptSyncProgress
-} from "./cli-79pzgqtj.js";
+} from "./cli-s3bcce69.js";
 import {
   promptSourceHashPayload
 } from "./cli-mm48br00.js";

package/dist/{sync-v0me021f.js → sync-xcjye7em.js}

@@ -6,11 +6,11 @@ import"./cli-rjav0vj1.js";
 import"./cli-hcwdz9sd.js";
 import {
   runPromptsCommand
-} from "./cli-79pzgqtj.js";
+} from "./cli-s3bcce69.js";
 import"./cli-mm48br00.js";
 import {
   runHarnessCommand
-} from "./cli-n3bjh1pc.js";
+} from "./cli-k6kydtkv.js";
 import"./cli-97fnztpy.js";
 import"./cli-xq45etg1.js";
 import"./cli-gtke9wrw.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.55.50",
+  "version": "1.55.51",
   "description": "CLI for Moda: production monitoring and evals for AI agents.",
   "type": "module",
   "bin": {

package/skills/integration/index.json

@@ -1,7 +1,7 @@
 {
   "schema_version": "moda.skill_index.v1",
-  "bundled_at": "2026-10-20T15:58:32.977Z",
-  "cli_version": "1.55.50",
+  "bundled_at": "2026-10-20T22:22:44.875Z",
+  "cli_version": "1.55.51",
   "skills": [
     {
       "id": "integration-cloudflare-think",