@moda-ai/cli 1.18.1 → 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
@@ -250,6 +251,10 @@ Init flags:
   --no-ci-cd                       Skip CI/CD workflow creation
   --autosync                       Create GitHub Actions workflow to sync prompts + skills to Moda on push to main
   --no-autosync                    Skip autosync workflow creation
+  --harness-rescan                 Create GitHub Actions workflow to re-scan the harness and sync it to Moda on push to main
+  --no-harness-rescan              Skip harness rescan workflow creation
+  --harness-rescan-paths=GLOBS     Comma-separated path globs that scope which pushes trigger the
+                                   harness rescan workflow (implies --harness-rescan)
   --offline                        Run final validation offline (skip the online telemetry check)
 
 Provision flags (headless; requires an existing "moda auth login" session):
@@ -289,9 +294,11 @@ 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
+  moda init --harness-rescan --harness-rescan-paths='src/agents/**'
   moda overview --days-back=30
   moda clusters --time-range=7d
   moda conversations --search="error" --limit=5
@@ -707,7 +714,7 @@ export const commandRegistry = createCommandRegistry([
     {
         name: 'init',
         description: 'Set up Moda in your project',
-        examples: ['moda init', 'moda init --sdk-integrate', 'moda init --ci-cd', 'moda init --autosync'],
+        examples: ['moda init', 'moda init --sdk-integrate', 'moda init --ci-cd', 'moda init --autosync', 'moda init --harness-rescan'],
         auth: 'none',
         outputModes: ['human', 'json', 'agent'],
         mutability: 'write',

package/dist/config.d.ts

@@ -28,6 +28,18 @@ export declare function saveCliConfig(update: CliConfig, options?: ProfileIOOpti
  * long-lived process (or a test) sees the current value.
  */
 export declare function resolveApiKey(options?: ProfileIOOptions): string | undefined;
+/**
+ * Signed CLI keys embed their tenant: the format is
+ * moda_sk_<base64url("v1:keyId:tenantId:timestamp:signature")> — see
+ * createApiKey/parseAndVerifySignedKey in
+ * apps/moda-backend/src/api-keys/api-keys.service.ts. The server derives the
+ * upload destination tenant from the key alone, so this is the only
+ * client-side tenant source that matches where data actually lands
+ * (config / MODA_TENANT_ID can disagree with a shadowing env key). The HMAC
+ * signature can only be verified server-side; treat the result as
+ * informational.
+ */
+export declare function embeddedTenantIdFromApiKey(key: string): string | undefined;
 /**
  * Resolve the ingest worker base URL used by `moda workspace snapshot`.
  * Env override -> active profile -> legacy config -> production default.

package/dist/config.js

@@ -40,6 +40,34 @@ export function resolveApiKey(options = {}) {
         loadCliConfig(options).api_key ||
         undefined);
 }
+const SIGNED_API_KEY_PREFIX = 'moda_sk_';
+const SIGNED_API_KEY_VERSION = 'v1';
+/**
+ * Signed CLI keys embed their tenant: the format is
+ * moda_sk_<base64url("v1:keyId:tenantId:timestamp:signature")> — see
+ * createApiKey/parseAndVerifySignedKey in
+ * apps/moda-backend/src/api-keys/api-keys.service.ts. The server derives the
+ * upload destination tenant from the key alone, so this is the only
+ * client-side tenant source that matches where data actually lands
+ * (config / MODA_TENANT_ID can disagree with a shadowing env key). The HMAC
+ * signature can only be verified server-side; treat the result as
+ * informational.
+ */
+export function embeddedTenantIdFromApiKey(key) {
+    if (!key.startsWith(SIGNED_API_KEY_PREFIX))
+        return undefined;
+    try {
+        const decoded = Buffer.from(key.slice(SIGNED_API_KEY_PREFIX.length), 'base64url').toString('utf8');
+        // Expected format: version:keyId:tenantId:timestamp:signature
+        const parts = decoded.split(':');
+        if (parts.length !== 5 || parts[0] !== SIGNED_API_KEY_VERSION)
+            return undefined;
+        return parts[2] || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Resolve the ingest worker base URL used by `moda workspace snapshot`.
  * Env override -> active profile -> legacy config -> production default.

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