@moda-ai/cli 1.19.0 → 1.19.1

package/dist/cli.js

@@ -141,6 +141,7 @@ Commands:
   harness validate-report          Validate .moda/harness-report.json citations
   harness approve                  Approve a validated harness report for sync
   harness scan                     Discover local runtime agents and write .moda/harness.json
+  harness candidates               Static (no-LLM) harness candidate pre-pass with file:line citations
   harness sync                     Sync the local harness graph to Moda Cloud
   harness agents                   List detected runtime agents and families
   harness explain                  Explain the discovered harness graph
@@ -293,6 +294,7 @@ Examples:
   moda sync --dry-run
   moda sync harness --profile=prod
   moda harness scan --json
+  moda harness candidates --out=.moda/harness-candidates.json
   moda harness explain --agent=agent_support
   moda init --ci-cd
   moda init --autosync

package/dist/harness-candidates.d.ts

@@ -0,0 +1,77 @@
+/**
+ * Static harness-candidate pre-pass (Phase 2 prototype).
+ *
+ * A deterministic, LLM-free detector that walks a repo and extracts
+ * *candidate* harness surfaces — LLM SDK call sites, agent-framework
+ * constructs, tool definitions/schemas, prompt files and prompt-like string
+ * literals, and model config assignments — each with a file:line citation,
+ * a confidence heuristic, and a short excerpt.
+ *
+ * Purpose: today `harness analyze` (local or hosted) has a single agent read
+ * everything, which caps out around ~450 files / ~20 minutes. This pre-pass is
+ * pure regex/heuristics (no LLM calls, no network), runs in milliseconds per
+ * thousand files, and produces a prioritized read plan so the LLM
+ * classification stage only needs to open the files that plausibly matter.
+ *
+ * Output contract: `harness_candidates.v0.1` — see {@link HarnessCandidateReport}.
+ * Candidates are recall-oriented: false positives are expected and cheap (the
+ * LLM stage filters them); false negatives are the expensive failure mode.
+ */
+import { type FileInventoryItem, type HarnessScanMetadata } from './harness.js';
+export type HarnessCandidateKind = 'llm_call_site' | 'framework_construct' | 'tool_definition' | 'tool_schema' | 'message_construction' | 'prompt_file' | 'prompt_literal' | 'model_config';
+export type HarnessCandidateConfidence = 'high' | 'medium' | 'low';
+export interface HarnessCandidate {
+    kind: HarnessCandidateKind;
+    /** Repo-relative, forward-slash path. */
+    path: string;
+    /** 1-based inclusive line range. */
+    startLine: number;
+    endLine: number;
+    confidence: HarnessCandidateConfidence;
+    /** Which detector fired, e.g. `openai.chat_completions_create`. */
+    signal: string;
+    /** Normalized single-line excerpt, capped at {@link EXCERPT_MAX_CHARS}. */
+    excerpt: string;
+}
+export interface HarnessCandidateFileSummary {
+    path: string;
+    /** Sum of per-candidate confidence weights; higher = read first. */
+    score: number;
+    kinds: HarnessCandidateKind[];
+    candidateCount: number;
+}
+export interface HarnessCandidateStats {
+    filesScanned: number;
+    filesWithCandidates: number;
+    candidateCount: number;
+    textBytesScanned: number;
+    durationMs: number;
+    filesPerSecond: number;
+}
+export interface HarnessCandidateReport {
+    schemaVersion: 'harness_candidates.v0.1';
+    generatedAt: string;
+    rootDir: string;
+    stats: HarnessCandidateStats;
+    candidates: HarnessCandidate[];
+    /** Per-file rollup sorted by descending score — the LLM-stage read plan. */
+    files: HarnessCandidateFileSummary[];
+    skipped: HarnessScanMetadata['skipped'];
+}
+/**
+ * Pure detector core: run every heuristic over an already-materialized file
+ * inventory. No filesystem access — unit tests and the walker wrapper both
+ * call this.
+ */
+export declare function detectHarnessCandidatesInFiles(files: Array<Pick<FileInventoryItem, 'path' | 'text'>>): {
+    candidates: HarnessCandidate[];
+    files: HarnessCandidateFileSummary[];
+};
+/**
+ * Walk `rootDir` with the harness inventory walker (same skip/secret/symlink
+ * budget rules as `harness scan`, widened to include all prompt-doc files)
+ * and run the static detector over it.
+ */
+export declare function detectHarnessCandidates(rootDir: string): HarnessCandidateReport;
+export declare function writeHarnessCandidatesReport(report: HarnessCandidateReport, outPath: string): string;
+//# sourceMappingURL=harness-candidates.d.ts.map

package/dist/harness-candidates.js

@@ -0,0 +1,482 @@
+/**
+ * Static harness-candidate pre-pass (Phase 2 prototype).
+ *
+ * A deterministic, LLM-free detector that walks a repo and extracts
+ * *candidate* harness surfaces — LLM SDK call sites, agent-framework
+ * constructs, tool definitions/schemas, prompt files and prompt-like string
+ * literals, and model config assignments — each with a file:line citation,
+ * a confidence heuristic, and a short excerpt.
+ *
+ * Purpose: today `harness analyze` (local or hosted) has a single agent read
+ * everything, which caps out around ~450 files / ~20 minutes. This pre-pass is
+ * pure regex/heuristics (no LLM calls, no network), runs in milliseconds per
+ * thousand files, and produces a prioritized read plan so the LLM
+ * classification stage only needs to open the files that plausibly matter.
+ *
+ * Output contract: `harness_candidates.v0.1` — see {@link HarnessCandidateReport}.
+ * Candidates are recall-oriented: false positives are expected and cheap (the
+ * LLM stage filters them); false negatives are the expensive failure mode.
+ */
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { basename, dirname, extname, resolve } from 'node:path';
+import { inventoryFiles, } from './harness.js';
+import { redactDeep } from './redact.js';
+const EXCERPT_MAX_CHARS = 240;
+const MAX_CANDIDATES_PER_FILE_PER_SIGNAL = 20;
+const MIN_PROMPT_LITERAL_CHARS = 160;
+const CONFIDENCE_WEIGHT = {
+    high: 3,
+    medium: 2,
+    low: 1,
+};
+const PY = ['.py'];
+const JS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+/**
+ * Line-anchored detector table. Every regex here must be safe to run on every
+ * line of every text file (no catastrophic backtracking), and every entry maps
+ * to exactly one candidate signal so results stay explainable.
+ */
+const LINE_PATTERNS = [
+    // ---- LLM SDK call sites -------------------------------------------------
+    {
+        kind: 'llm_call_site', signal: 'openai.import', confidence: 'high',
+        pattern: /(^\s*(import|from)\s+openai\b)|(\bfrom\s+['"]openai['"])|(\brequire\(\s*['"]openai['"]\s*\))/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'openai.client_construct', confidence: 'high',
+        pattern: /\b(new\s+)?(Async)?(OpenAI|AzureOpenAI)\s*\(/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'openai.chat_completions_create', confidence: 'high',
+        pattern: /\.\s*(chat\s*\.\s*)?completions\s*\.\s*(create|parse|stream)\s*\(|\.\s*responses\s*\.\s*(create|parse|stream)\s*\(/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'anthropic.import', confidence: 'high',
+        pattern: /(^\s*(import|from)\s+anthropic\b)|(@anthropic-ai\/sdk)|(\bfrom\s+['"]@anthropic-ai\/)/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'anthropic.client_or_messages', confidence: 'high',
+        pattern: /\b(new\s+)?(Async)?Anthropic(Bedrock|Vertex)?\s*\(|\.\s*messages\s*\.\s*(create|stream)\s*\(/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'openrouter.reference', confidence: 'medium',
+        pattern: /openrouter\.ai|OPENROUTER_API_KEY|\bopen_?router\b/i,
+    },
+    {
+        kind: 'llm_call_site', signal: 'vercel_ai_sdk.generate', confidence: 'high',
+        pattern: /\b(generateText|streamText|generateObject|streamObject)\s*\(/,
+        extensions: JS,
+    },
+    {
+        kind: 'llm_call_site', signal: 'litellm.reference', confidence: 'high',
+        pattern: /\blitellm\b/,
+        extensions: PY,
+    },
+    {
+        kind: 'llm_call_site', signal: 'google_genai.reference', confidence: 'high',
+        pattern: /google\.generativeai|@google\/generative-ai|@google\/genai|\bGenerativeModel\s*\(/,
+    },
+    {
+        kind: 'llm_call_site', signal: 'bedrock.invoke_model', confidence: 'medium',
+        pattern: /\binvoke_model\s*\(|InvokeModelCommand|bedrock-runtime/,
+    },
+    // ---- Agent framework constructs ----------------------------------------
+    {
+        kind: 'framework_construct', signal: 'langchain.import', confidence: 'high',
+        pattern: /(^\s*(import|from)\s+langchain\w*\b)|(\bfrom\s+['"]@?langchain\b)|(@langchain\/)/,
+    },
+    {
+        kind: 'framework_construct', signal: 'langchain.construct', confidence: 'high',
+        pattern: /\b(ChatOpenAI|ChatAnthropic|ChatVertexAI|ChatBedrock|AgentExecutor|LLMChain|ChatPromptTemplate|PromptTemplate)\s*(\(|\.)/,
+    },
+    {
+        kind: 'framework_construct', signal: 'langgraph.import_or_graph', confidence: 'high',
+        pattern: /(^\s*(import|from)\s+langgraph\b)|(@langchain\/langgraph)|\bStateGraph\s*\(|\bcreate_react_agent\s*\(/,
+    },
+    {
+        kind: 'framework_construct', signal: 'crewai.import_or_crew', confidence: 'high',
+        pattern: /(^\s*(import|from)\s+crewai\b)|\bcrewai\b/,
+    },
+    {
+        kind: 'framework_construct', signal: 'openai_agents.import_or_runner', confidence: 'high',
+        pattern: /(^\s*from\s+agents\s+import\b)|\bopenai-agents\b|\bRunner\s*\.\s*run(_sync|_streamed)?\s*\(/,
+    },
+    {
+        kind: 'framework_construct', signal: 'claude_agent_sdk.import', confidence: 'high',
+        pattern: /@anthropic-ai\/claude-agent-sdk|\bclaude_agent_sdk\b|\bclaude-agent-sdk\b/,
+    },
+    {
+        kind: 'framework_construct', signal: 'other_framework.import', confidence: 'medium',
+        pattern: /(^\s*(import|from)\s+(autogen|pydantic_ai|dspy|semantic_kernel|smolagents|llama_index)\b)|\bfrom\s+['"]llamaindex['"]/,
+    },
+    // ---- Tool definitions ---------------------------------------------------
+    {
+        kind: 'tool_definition', signal: 'python.tool_decorator', confidence: 'high',
+        pattern: /^\s*@(tool|function_tool|mcp\.tool|app\.tool)\b/,
+        extensions: PY,
+    },
+    {
+        kind: 'tool_definition', signal: 'python.base_tool_subclass', confidence: 'high',
+        pattern: /class\s+\w+\s*\(\s*(BaseTool|StructuredTool)\b/,
+        extensions: PY,
+    },
+    {
+        kind: 'tool_definition', signal: 'js.ai_sdk_tool', confidence: 'medium',
+        pattern: /\btool\s*\(\s*\{|\bcreateTool\s*\(|\bDynamicStructuredTool\s*\(/,
+        extensions: JS,
+    },
+    {
+        kind: 'tool_definition', signal: 'tool_registry.registration', confidence: 'medium',
+        pattern: /\b(register_tool|registerTool|add_tool|ToolRegistry)\s*\(/,
+    },
+    // ---- Tool schema dicts --------------------------------------------------
+    {
+        kind: 'tool_schema', signal: 'openai.function_schema', confidence: 'high',
+        pattern: /["']type["']\s*:\s*["']function["']/,
+    },
+    {
+        kind: 'tool_schema', signal: 'anthropic.input_schema', confidence: 'high',
+        pattern: /\binput_schema\b|\binputSchema\s*[:=]/,
+    },
+    {
+        kind: 'tool_schema', signal: 'json_schema.parameters_block', confidence: 'medium',
+        pattern: /["']parameters["']\s*:\s*\{/,
+    },
+    // ---- Message construction (weak corroborating signal) -------------------
+    {
+        kind: 'message_construction', signal: 'chat.role_content_dict', confidence: 'low',
+        pattern: /["']role["']\s*:\s*["'](system|user|assistant|tool)["']|\brole\s*=\s*["'](system|user|assistant)["']/,
+    },
+    // ---- Model config assignments -------------------------------------------
+    {
+        kind: 'model_config', signal: 'model.assignment', confidence: 'high',
+        pattern: /\b(model|model_name|model_id|modelName|modelId|MODEL[A-Z_]*)\s*[:=]\s*["'`][\w.:/-]*(gpt-|o[134](-mini)?\b|claude|gemini|llama|mistral|mixtral|deepseek|qwen|grok|sonnet|opus|haiku|command-r|glm|gemma)[\w.:/-]*["'`]/i,
+    },
+    {
+        kind: 'model_config', signal: 'model.env_default', confidence: 'medium',
+        pattern: /\b(OPENAI_MODEL|ANTHROPIC_MODEL|MODEL_NAME|LLM_MODEL|DEFAULT_MODEL)\b/,
+    },
+];
+const CODE_EXTENSIONS = new Set([...JS, ...PY]);
+const PROMPT_DOC_EXTENSIONS = new Set(['.md', '.mdc', '.txt', '.prompt', '.jinja', '.jinja2', '.j2', '.hbs', '.tpl']);
+const NON_PROMPT_DOC_BASENAMES = new Set([
+    'readme.md', 'agents.md', 'claude.md', 'changelog.md', 'contributing.md',
+    'license.md', 'license.txt', 'code_of_conduct.md', 'security.md', 'requirements.txt',
+]);
+const PROMPT_NAME_HINT = /(prompt|system[-_]?message|instruction|persona|sop)/i;
+const AGENTIC_DIR_HINT = /(^|\/)(agents?|prompts?|llm|ai|assistants?|chains?|crew|graph)s?(\/|$)/i;
+const INSTRUCTION_MARKERS = [
+    /\byou are\b/i,
+    /\byou're\s+(a|an|the)\b/i,
+    /\byour (task|role|job|goal|objective)\b/i,
+    /\b(do not|don't|never|always|must|should)\b/i,
+    /\brespond (with|only|in|using)\b/i,
+    /\bstep[- ]by[- ]step\b/i,
+    /\binstructions?\b/i,
+    /\bassistant\b/i,
+    /\bthe user\b/i,
+    /\bif the user\b/i,
+];
+function instructionScore(text) {
+    let score = 0;
+    for (const marker of INSTRUCTION_MARKERS) {
+        if (marker.test(text))
+            score += 1;
+    }
+    return score;
+}
+function normalizeExcerpt(text) {
+    const collapsed = text.replace(/\s+/g, ' ').trim();
+    return collapsed.length > EXCERPT_MAX_CHARS
+        ? `${collapsed.slice(0, EXCERPT_MAX_CHARS - 1)}…`
+        : collapsed;
+}
+/** Map a character index into 1-based line numbers using precomputed offsets. */
+function buildLineIndex(text) {
+    const offsets = [0];
+    for (let i = 0; i < text.length; i += 1) {
+        if (text.charCodeAt(i) === 10)
+            offsets.push(i + 1);
+    }
+    return offsets;
+}
+function lineAtIndex(offsets, index) {
+    let lo = 0;
+    let hi = offsets.length - 1;
+    while (lo < hi) {
+        const mid = (lo + hi + 1) >> 1;
+        if (offsets[mid] <= index)
+            lo = mid;
+        else
+            hi = mid - 1;
+    }
+    return lo + 1;
+}
+function detectLinePatterns(file, out) {
+    const ext = extname(file.path).toLowerCase();
+    const lines = file.text.split('\n');
+    const perSignal = new Map();
+    for (const pattern of LINE_PATTERNS) {
+        if (pattern.extensions && !pattern.extensions.includes(ext))
+            continue;
+        for (let i = 0; i < lines.length; i += 1) {
+            const line = lines[i];
+            if (line.length > 4000)
+                continue; // minified/bundled line — skip, not agent source
+            if (!pattern.pattern.test(line))
+                continue;
+            const seen = perSignal.get(pattern.signal) ?? 0;
+            if (seen >= MAX_CANDIDATES_PER_FILE_PER_SIGNAL)
+                break;
+            perSignal.set(pattern.signal, seen + 1);
+            out.push({
+                kind: pattern.kind,
+                path: file.path,
+                startLine: i + 1,
+                endLine: i + 1,
+                confidence: pattern.confidence,
+                signal: pattern.signal,
+                excerpt: normalizeExcerpt(line),
+            });
+        }
+    }
+}
+/** A line that is (only) a string literal, optionally with prefix/trailing punctuation. */
+const STRING_ONLY_LINE = /^\s*[frbu]{0,3}("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')\s*[,)\]]*;?\s*$/i;
+const MIN_ADJACENT_STRING_LINES = 4;
+/**
+ * Prompts assembled from runs of adjacent single-line string literals
+ * (Python implicit concatenation, JS `[...].join('\n')` arrays). The
+ * triple-quote/template-literal scan cannot see these.
+ */
+function detectAdjacentStringBlocks(file, out) {
+    const lines = file.text.split('\n');
+    let blockStart = -1;
+    let parts = [];
+    let found = 0;
+    const flush = (endLineIndex) => {
+        const start = blockStart;
+        blockStart = -1;
+        const content = parts.join('\n');
+        parts = [];
+        if (start === -1 || endLineIndex - start + 1 < MIN_ADJACENT_STRING_LINES)
+            return;
+        if (content.length < MIN_PROMPT_LITERAL_CHARS)
+            return;
+        const score = instructionScore(content);
+        if (score < 2)
+            return;
+        if (found >= MAX_CANDIDATES_PER_FILE_PER_SIGNAL)
+            return;
+        found += 1;
+        out.push({
+            kind: 'prompt_literal',
+            path: file.path,
+            startLine: start + 1,
+            endLine: endLineIndex + 1,
+            confidence: score >= 4 || content.length >= 600 ? 'high' : 'medium',
+            signal: 'code.adjacent_string_block',
+            excerpt: normalizeExcerpt(content),
+        });
+    };
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = lines[i].length <= 4000 ? STRING_ONLY_LINE.exec(lines[i]) : null;
+        if (match) {
+            if (blockStart === -1)
+                blockStart = i;
+            parts.push(match[1].slice(1, -1));
+        }
+        else {
+            flush(i - 1);
+        }
+    }
+    flush(lines.length - 1);
+}
+const PROMPT_MODULE_NAME_HINT = /(^|[._-])(system[._-]?)?prompts?([._-]|$)/i;
+/** Code modules named like prompt builders (system_prompt.py, prompts.ts, ...). */
+function detectPromptModule(file, out) {
+    const base = basename(file.path, extname(file.path));
+    if (!PROMPT_MODULE_NAME_HINT.test(base))
+        return;
+    out.push({
+        kind: 'prompt_file',
+        path: file.path,
+        startLine: 1,
+        endLine: Math.max(1, file.text.split('\n').length),
+        confidence: 'medium',
+        signal: 'prompt_module.name_hint',
+        excerpt: normalizeExcerpt(file.text.slice(0, EXCERPT_MAX_CHARS * 2)),
+    });
+}
+/**
+ * Multi-line string literal scan: Python triple-quoted strings and JS/TS
+ * template literals whose contents are long and instruction-like.
+ */
+function detectPromptLiterals(file, out) {
+    const ext = extname(file.path).toLowerCase();
+    const offsets = buildLineIndex(file.text);
+    let found = 0;
+    const record = (startIndex, endIndex, content, signal) => {
+        if (content.length < MIN_PROMPT_LITERAL_CHARS)
+            return;
+        const score = instructionScore(content);
+        if (score < 2)
+            return;
+        if (found >= MAX_CANDIDATES_PER_FILE_PER_SIGNAL)
+            return;
+        found += 1;
+        out.push({
+            kind: 'prompt_literal',
+            path: file.path,
+            startLine: lineAtIndex(offsets, startIndex),
+            endLine: lineAtIndex(offsets, endIndex),
+            confidence: score >= 4 || content.length >= 600 ? 'high' : 'medium',
+            signal,
+            excerpt: normalizeExcerpt(content),
+        });
+    };
+    if (ext === '.py') {
+        const tripleQuoted = /("""|''')([\s\S]*?)\1/g;
+        let match;
+        while ((match = tripleQuoted.exec(file.text)) !== null) {
+            record(match.index, match.index + match[0].length - 1, match[2], 'python.triple_quoted_string');
+        }
+        return;
+    }
+    if (CODE_EXTENSIONS.has(ext)) {
+        // Approximate template-literal spans: toggle on unescaped backticks. Nested
+        // ${`...`} interpolation can split a literal in two — acceptable for a
+        // recall-oriented heuristic (both halves are still instruction-scored).
+        let start = -1;
+        for (let i = 0; i < file.text.length; i += 1) {
+            if (file.text[i] !== '`' || (i > 0 && file.text[i - 1] === '\\'))
+                continue;
+            if (start === -1) {
+                start = i;
+            }
+            else {
+                record(start, i, file.text.slice(start + 1, i), 'js.template_literal');
+                start = -1;
+            }
+        }
+    }
+}
+function detectPromptFile(file, out) {
+    const ext = extname(file.path).toLowerCase();
+    if (!PROMPT_DOC_EXTENSIONS.has(ext))
+        return;
+    const base = basename(file.path).toLowerCase();
+    if (NON_PROMPT_DOC_BASENAMES.has(base))
+        return;
+    if (/(^|\/)(docs?|documentation|examples?|\.github)\//i.test(file.path))
+        return;
+    const dir = dirname(file.path);
+    const nameHint = PROMPT_NAME_HINT.test(base);
+    const dirHint = AGENTIC_DIR_HINT.test(dir);
+    const score = instructionScore(file.text.slice(0, 20_000));
+    let confidence;
+    let signal;
+    if (nameHint) {
+        confidence = 'high';
+        signal = 'prompt_file.name_hint';
+    }
+    else if (dirHint && score >= 3) {
+        confidence = 'medium';
+        signal = 'prompt_file.agent_dir_instruction_text';
+    }
+    else if (score >= 5) {
+        confidence = 'low';
+        signal = 'prompt_file.instruction_text';
+    }
+    if (!confidence || !signal)
+        return;
+    out.push({
+        kind: 'prompt_file',
+        path: file.path,
+        startLine: 1,
+        endLine: Math.max(1, file.text.split('\n').length),
+        confidence,
+        signal,
+        excerpt: normalizeExcerpt(file.text.slice(0, EXCERPT_MAX_CHARS * 2)),
+    });
+}
+/**
+ * Pure detector core: run every heuristic over an already-materialized file
+ * inventory. No filesystem access — unit tests and the walker wrapper both
+ * call this.
+ */
+export function detectHarnessCandidatesInFiles(files) {
+    const candidates = [];
+    for (const file of files) {
+        if (typeof file.text !== 'string' || file.text.length === 0)
+            continue;
+        const scoped = { path: file.path, text: file.text };
+        const ext = extname(file.path).toLowerCase();
+        if (CODE_EXTENSIONS.has(ext) || ext === '.json' || ext === '.yaml' || ext === '.yml' || ext === '.toml') {
+            detectLinePatterns(scoped, candidates);
+        }
+        if (CODE_EXTENSIONS.has(ext)) {
+            detectAdjacentStringBlocks(scoped, candidates);
+            detectPromptModule(scoped, candidates);
+        }
+        detectPromptLiterals(scoped, candidates);
+        detectPromptFile(scoped, candidates);
+    }
+    candidates.sort((a, b) => a.path === b.path ? a.startLine - b.startLine || a.signal.localeCompare(b.signal) : a.path.localeCompare(b.path));
+    const byFile = new Map();
+    for (const candidate of candidates) {
+        let summary = byFile.get(candidate.path);
+        if (!summary) {
+            summary = { path: candidate.path, score: 0, kinds: [], candidateCount: 0 };
+            byFile.set(candidate.path, summary);
+        }
+        summary.score += CONFIDENCE_WEIGHT[candidate.confidence];
+        summary.candidateCount += 1;
+        if (!summary.kinds.includes(candidate.kind))
+            summary.kinds.push(candidate.kind);
+    }
+    const fileSummaries = [...byFile.values()].sort((a, b) => b.score - a.score || a.path.localeCompare(b.path));
+    return { candidates, files: fileSummaries };
+}
+/**
+ * Walk `rootDir` with the harness inventory walker (same skip/secret/symlink
+ * budget rules as `harness scan`, widened to include all prompt-doc files)
+ * and run the static detector over it.
+ */
+export function detectHarnessCandidates(rootDir) {
+    const startedAt = Date.now();
+    const skipped = [];
+    const root = resolve(rootDir);
+    const inventory = inventoryFiles(root, skipped, {
+        includeFile: (path) => PROMPT_DOC_EXTENSIONS.has(extname(path).toLowerCase()),
+    });
+    const { candidates, files } = detectHarnessCandidatesInFiles(inventory);
+    const durationMs = Math.max(1, Date.now() - startedAt);
+    const textBytesScanned = inventory.reduce((sum, file) => sum + (file.text ? Buffer.byteLength(file.text, 'utf8') : 0), 0);
+    const report = {
+        schemaVersion: 'harness_candidates.v0.1',
+        generatedAt: new Date().toISOString(),
+        rootDir: root,
+        stats: {
+            filesScanned: inventory.length,
+            filesWithCandidates: files.length,
+            candidateCount: candidates.length,
+            textBytesScanned,
+            durationMs,
+            filesPerSecond: Math.round((inventory.length / durationMs) * 1000),
+        },
+        candidates,
+        files,
+        skipped,
+    };
+    // Excerpts quote user source verbatim; strip anything token-shaped before
+    // the report leaves the process.
+    return redactDeep(report);
+}
+export function writeHarnessCandidatesReport(report, outPath) {
+    const target = resolve(outPath);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(report, null, 2)}\n`, 'utf8');
+    return target;
+}
+//# sourceMappingURL=harness-candidates.js.map

package/dist/harness.d.ts

@@ -173,6 +173,12 @@ export interface HarnessGraph {
     relationships: HarnessRelationship[];
     unknowns: HarnessUnknown[];
 }
+export interface FileInventoryItem {
+    path: string;
+    absPath: string;
+    rootDir: string;
+    text?: string;
+}
 interface ScanOptions {
     rootDir?: string;
     dryRun?: boolean;
@@ -439,6 +445,18 @@ export declare function writeHarnessArtifacts(graph: HarnessGraph, rootDir: stri
     summary?: boolean;
 }): string[];
 export declare function graphForSync(graph: HarnessGraph): HarnessGraph;
+/**
+ * Bounded repo walk shared by `harness scan`, snapshot upload, and the static
+ * candidates pre-pass: skips ignored/secret-bearing paths and symlinks,
+ * enforces the file-count and text-byte budgets, and reads text for known
+ * text extensions plus any file admitted by `options.includeFile`.
+ * `options.includeFile` widens (ORs with) the default inventory predicate and
+ * also opts its files into text reading — it can never re-admit secret-bearing
+ * or oversized files, which are rejected before the predicate runs.
+ */
+export declare function inventoryFiles(rootDir: string, skipped: HarnessScanMetadata['skipped'], options?: {
+    includeFile?: (relPath: string) => boolean;
+}): FileInventoryItem[];
 export declare function numericEnv(name: string, fallback: number): number;
 export declare function numericEnvAllowZero(name: string, fallback: number): number;
 export {};

package/dist/harness.js

@@ -12,6 +12,7 @@ import { HARNESS_REMOTE_RUN_STATE_PATH, isRemoteHarnessAnalyze, readRemoteRunSta
 import { getActiveProfile } from './profiles.js';
 import { enrichScanCaptureMetadata, annotatedSourceCandidates, extractToolBody, hydratePromptAndToolBodies, readPromptOrToolBody, resolveAnnotatedSourcePath, } from './harness-artifact-bodies.js';
 import { approveHarnessReport, createHarnessReport, graphForReport, hashHarnessReport, hashStableJson as hashHarnessReportStableJson, HARNESS_REPORT_PATH, loadHarnessReportForSync, normalizeHarnessReport, readHarnessReport, resolveHarnessReportPath, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
+import { detectHarnessCandidates, writeHarnessCandidatesReport } from './harness-candidates.js';
 import { assertHarnessGraphSyncSize } from './harness-sync-limits.js';
 import { renderHarnessAnalystChoice, renderHarnessAnalystLaunch, renderHarnessAnalystPreflight, renderHarnessAnalyzeHumanResult, renderHarnessProgress, } from './tui.js';
 const MODA_DIR = '.moda';
@@ -381,6 +382,29 @@ export async function runHarnessCommand(context) {
             });
             return { exitCode: 0 };
         }
+        case 'candidates': {
+            await approveScanIfNeeded(scanPlan, {
+                context,
+                message: 'Scan this project for static harness candidates?',
+            });
+            writeHumanProgress(context, 'Harness candidates: static pre-pass (no LLM, no network)...');
+            const report = detectHarnessCandidates(rootDir);
+            const written = [];
+            const outFlag = context.flags.out;
+            // A value-less `--out` is parsed as the sentinel string 'true'; reject it
+            // rather than silently writing the report to `<cwd>/true`.
+            if (outFlag === 'true') {
+                throw new CliInputError('Missing output path for --out.', 'Usage: moda harness candidates --out=<file>');
+            }
+            if (outFlag && !context.dryRun) {
+                written.push(writeHarnessCandidatesReport(report, resolve(context.cwd, outFlag)));
+            }
+            writeHumanProgress(context, `Harness candidates: ${report.stats.candidateCount} candidates across ` +
+                `${report.stats.filesWithCandidates} files (${report.stats.filesScanned} scanned, ` +
+                `${report.stats.filesPerSecond.toLocaleString()} files/sec).`);
+            context.output.writeData({ scanPlan, ...report, written, dryRun: context.dryRun });
+            return { exitCode: 0 };
+        }
         case 'agents': {
             const graph = loadOrScanHarness(rootDir, tenant, context);
             context.output.writeData({
@@ -470,7 +494,7 @@ export async function runHarnessCommand(context) {
             return { exitCode: 0 };
         }
         default:
-            throw new CliInputError(`Unknown harness command '${subcommand}'.`, 'Usage: moda harness analyze|pull|validate-report|approve|scan|sync|agents|graph|explain|write-summary|status');
+            throw new CliInputError(`Unknown harness command '${subcommand}'.`, 'Usage: moda harness analyze|pull|validate-report|approve|scan|candidates|sync|agents|graph|explain|write-summary|status');
     }
 }
 export function writeHarnessAnalyzeResult(context, payload) {
@@ -2406,7 +2430,16 @@ function explainAgent(graph, agent) {
         relationships: graph.relationships.filter((relationship) => relationship.from === agent.id || relationship.to === agent.id),
     };
 }
-function inventoryFiles(rootDir, skipped) {
+/**
+ * Bounded repo walk shared by `harness scan`, snapshot upload, and the static
+ * candidates pre-pass: skips ignored/secret-bearing paths and symlinks,
+ * enforces the file-count and text-byte budgets, and reads text for known
+ * text extensions plus any file admitted by `options.includeFile`.
+ * `options.includeFile` widens (ORs with) the default inventory predicate and
+ * also opts its files into text reading — it can never re-admit secret-bearing
+ * or oversized files, which are rejected before the predicate runs.
+ */
+export function inventoryFiles(rootDir, skipped, options = {}) {
     const files = [];
     const rootReal = resolve(rootDir);
     const maxFiles = numericEnv('MODA_HARNESS_MAX_FILES', DEFAULT_MAX_INVENTORY_FILES);
@@ -2446,7 +2479,7 @@ function inventoryFiles(rootDir, skipped) {
             recordSkipped(skipped, { path: rel, reason: 'secret-bearing file skipped' });
             return;
         }
-        if (!shouldInventoryFile(rel))
+        if (!shouldInventoryFile(rel) && !(options.includeFile?.(rel) ?? false))
             return;
         if (files.length >= maxFiles) {
             throwHarnessScanTooBroad(rootReal, {
@@ -2458,7 +2491,12 @@ function inventoryFiles(rootDir, skipped) {
             });
         }
         const item = { path: rel, absPath: current, rootDir: rootReal };
-        if (isTextFile(rel)) {
+        // Read text for known text extensions, but also for any file the caller
+        // widened in via `includeFile` (e.g. the candidates pass admits template
+        // prompt files like `.jinja`/`.hbs`/`.tpl`/`.prompt` whose extensions are
+        // not in `isTextFile`) — otherwise a widened-in file is counted as scanned
+        // but never gets its text read, so downstream detectors silently skip it.
+        if (isTextFile(rel) || (options.includeFile?.(rel) ?? false)) {
             if (textBytes + stat.size > maxTextBytes) {
                 recordSkipped(skipped, { path: rel, reason: 'scan text budget exceeded' });
             }

package/dist/redact.js

@@ -19,6 +19,15 @@ const SECRET_PATTERNS = [
     { pattern: /\bmoda_ct_[A-Za-z0-9_-]+\b/g, prefixLength: 8 },
     { pattern: /\bBearer\s+([A-Za-z0-9._~+/-]+=*)\b/gi, prefixLength: 8 },
     { pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, prefixLength: 8 },
+    // Third-party provider credentials that can appear inline in scanned source
+    // (e.g. harness-candidate excerpts) — the detectors deliberately fire on the
+    // very lines most likely to carry hardcoded keys.
+    { pattern: /\bsk-ant-api\d{2}-[A-Za-z0-9_-]{20,}\b/g, prefixLength: 12 }, // Anthropic
+    { pattern: /\bsk-(?:proj-|svcacct-)?[A-Za-z0-9_-]{20,}\b/g, prefixLength: 8 }, // OpenAI
+    { pattern: /\bAKIA[A-Z0-9]{16}\b/g, prefixLength: 8 }, // AWS access key id
+    { pattern: /\bAIza[A-Za-z0-9_-]{35}\b/g, prefixLength: 8 }, // Google API key
+    { pattern: /\bgh[pousr]_[A-Za-z0-9]{36,}\b/g, prefixLength: 8 }, // GitHub token
+    { pattern: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/g, prefixLength: 8 }, // Slack token
 ];
 export function redactDeep(value) {
     return redactValue(value, 0, new WeakSet());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.19.0",
+  "version": "1.19.1",
   "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-07-11T00:30:28.897Z",
-  "cli_version": "1.19.0",
+  "bundled_at": "2026-07-11T01:00:37.487Z",
+  "cli_version": "1.19.1",
   "skills": [
     {
       "id": "integration-node-anthropic",