@moda-ai/cli 1.12.0 → 1.12.3

package/dist/cli.js

@@ -219,6 +219,9 @@ Init flags:
   --yes                            Accept all defaults (non-interactive)
   --analyst=auto|claude|codex|cursor|local-scan
                                    Choose harness analyst adapter
+  --remote                         Run harness analysis server-side (Moda-hosted):
+                                   upload a safe source snapshot; no local agent
+                                   (also MODA_HARNESS_REMOTE=1)
   --tui                            Show full-screen analyst dashboard in human TTYs
   --no-tui                         Show raw external analyst output
   --sdk-integrate                  Run your coding agent to install the Moda SDK and instrument LLM calls
@@ -238,6 +241,7 @@ Examples:
   moda profiles use staging
   moda config show --profile=prod
   moda harness analyze --summary
+  moda harness analyze --remote
   moda harness analyze --analyst=claude --tui
   moda harness analyze --analyst=claude --no-tui
   moda harness analyze --analyst=claude --summary
@@ -829,6 +833,7 @@ export const commandRegistry = createCommandRegistry([
         description: 'Analyze, validate, approve, sync, and explain the local multi-agent harness graph',
         examples: [
             'moda harness analyze --summary',
+            'moda harness analyze --remote',
             'moda harness approve --yes',
             'moda harness sync --from-report .moda/harness-report.json',
             'moda harness explain --agent=agent_support',

package/dist/harness-remote.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Server-side ("Moda-hosted") harness analyze client.
+ *
+ * `moda harness analyze --remote` builds a safe source snapshot with
+ * `buildSourceSnapshot` (harness.ts), uploads it to the ingest worker
+ * (`POST /v1/harness/analyze`), polls `GET /v1/harness/analyze/:id` for the
+ * validated report, then writes the same local artifacts and emits the same
+ * lifecycle events as the local analyze paths.
+ */
+import type { CommandContext } from './command-context.js';
+import { type HarnessCommandScanPlan, type HarnessTenantContext } from './harness.js';
+/**
+ * True when `moda harness analyze` should run server-side (Moda-hosted) instead
+ * of spawning a local coding agent: `--remote` (flags.remote === 'true') or the
+ * `MODA_HARNESS_REMOTE` env opt-in.
+ */
+export declare function isRemoteHarnessAnalyze(context: CommandContext): boolean;
+/**
+ * Server-side ("Moda-hosted") harness analysis. Builds a safe source snapshot,
+ * uploads it to the ingest worker, polls for the validated report, then writes
+ * the same local artifacts the local analyze path writes. Emits the same
+ * lifecycle events so `--agent --stream` behaves consistently with the local
+ * path.
+ */
+export declare function runRemoteHarnessAnalyst(options: {
+    context: CommandContext;
+    rootDir: string;
+    scanPlan: HarnessCommandScanPlan;
+    tenant?: HarnessTenantContext;
+}): Promise<{
+    exitCode: number;
+}>;
+//# sourceMappingURL=harness-remote.d.ts.map

package/dist/harness-remote.js

@@ -0,0 +1,203 @@
+/**
+ * Server-side ("Moda-hosted") harness analyze client.
+ *
+ * `moda harness analyze --remote` builds a safe source snapshot with
+ * `buildSourceSnapshot` (harness.ts), uploads it to the ingest worker
+ * (`POST /v1/harness/analyze`), polls `GET /v1/harness/analyze/:id` for the
+ * validated report, then writes the same local artifacts and emits the same
+ * lifecycle events as the local analyze paths.
+ */
+import { resolveApiKey, resolveIngestUrl } from './config.js';
+import { CliInputError } from './errors.js';
+import { normalizeHarnessReport, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
+import { buildSourceSnapshot, emitWrittenArtifacts, numericEnv, numericEnvAllowZero, repairExternalAnalystReport, sleep, summarizeHarness, summarizeInvalidAnalystReport, truncateText, writeHarnessAnalyzeResult, writeHarnessArtifacts, writeHumanProgress, } from './harness.js';
+const DEFAULT_REMOTE_ANALYZE_TIMEOUT_MS = 900_000;
+const DEFAULT_REMOTE_POLL_INITIAL_MS = 3_000;
+const DEFAULT_REMOTE_POLL_MAX_MS = 15_000;
+/** Lower bound on the inter-poll delay so a 0 interval can't busy-loop the status endpoint. */
+const MIN_REMOTE_POLL_DELAY_MS = 250;
+const REMOTE_UPLOAD_TIMEOUT_MS = 120_000;
+const REMOTE_STATUS_TIMEOUT_MS = 30_000;
+/**
+ * True when `moda harness analyze` should run server-side (Moda-hosted) instead
+ * of spawning a local coding agent: `--remote` (flags.remote === 'true') or the
+ * `MODA_HARNESS_REMOTE` env opt-in.
+ */
+export function isRemoteHarnessAnalyze(context) {
+    // The CLI normalizes numeric flag values to numbers, so `--remote=1` arrives
+    // as the number 1 rather than the string '1'; accept every truthy spelling.
+    const flag = context.flags.remote;
+    if (flag === true || flag === 1 || flag === 'true' || flag === '1' || flag === 'yes')
+        return true;
+    const env = (context.env.MODA_HARNESS_REMOTE ?? '').trim().toLowerCase();
+    return env !== '' && env !== '0' && env !== 'false';
+}
+/**
+ * Server-side ("Moda-hosted") harness analysis. Builds a safe source snapshot,
+ * uploads it to the ingest worker, polls for the validated report, then writes
+ * the same local artifacts the local analyze path writes. Emits the same
+ * lifecycle events so `--agent --stream` behaves consistently with the local
+ * path.
+ */
+export async function runRemoteHarnessAnalyst(options) {
+    const { context, rootDir } = options;
+    if (context.dryRun) {
+        throw new CliInputError('Remote harness analysis cannot run in dry-run mode.', 'Use `moda harness analyze --analyst=local-scan --dry-run` for deterministic local inspection.');
+    }
+    const apiKey = resolveApiKey({ profile: context.profile, env: context.env });
+    if (!apiKey) {
+        throw new CliInputError('No Moda API key found for remote harness analysis.', 'Run `moda init` first (or set MODA_API_KEY), then rerun `moda harness analyze --remote`.');
+    }
+    const ingestUrl = resolveIngestUrl({ profile: context.profile, env: context.env }).replace(/\/+$/, '');
+    context.output.writeEvent({
+        event: 'progress',
+        phase: 'inventory',
+        message: 'Inventorying local harness files for upload.',
+        elapsed_ms: Date.now() - context.startedAt,
+    });
+    writeHumanProgress(context, 'Moda Analyst (remote): inventorying local harness files...');
+    const snapshot = buildSourceSnapshot(rootDir);
+    context.output.writeEvent({
+        event: 'progress',
+        phase: 'remote_upload',
+        message: `Uploading ${snapshot.fileCount} file(s) (${snapshot.byteCount} bytes) to Moda for server-side analysis.`,
+        elapsed_ms: Date.now() - context.startedAt,
+    });
+    writeHumanProgress(context, `Moda Analyst (remote): uploading ${snapshot.fileCount} file(s) for server-side analysis...`);
+    const accepted = await postRemoteAnalyze(ingestUrl, apiKey, {
+        snapshot,
+        options: buildRemoteAnalyzeOptions(context.flags),
+    });
+    const runId = accepted.analysis_run_id;
+    context.output.writeEvent({
+        event: 'progress',
+        phase: 'remote_wait',
+        message: `Moda accepted analysis run ${runId}; waiting for the server-side agent.`,
+        elapsed_ms: Date.now() - context.startedAt,
+    });
+    writeHumanProgress(context, `Moda Analyst (remote): analysis run ${runId} accepted; waiting for results...`);
+    const final = await pollRemoteAnalyze({ ingestUrl, apiKey, runId, context });
+    if (final.status !== 'completed' || !final.report) {
+        const detail = final.status === 'failed'
+            ? `Remote harness analysis failed: ${final.error ?? 'unknown error'}.`
+            : `Remote harness analysis did not finish before the timeout (last status: ${final.status}).`;
+        throw new CliInputError(detail, [
+            `Retry \`moda harness analyze --remote\`${runId ? ` (run ${runId})` : ''}.`,
+            'Or run `moda harness analyze --analyst=local-scan` to analyze locally.',
+            'Increase MODA_HARNESS_REMOTE_TIMEOUT_MS if large repos need longer.',
+        ].join('\n'));
+    }
+    const report = repairExternalAnalystReport(normalizeHarnessReport(final.report), rootDir);
+    const validation = validateHarnessReport(report, rootDir);
+    context.output.writeEvent({
+        event: 'progress',
+        phase: 'validation',
+        message: `Harness report validation ${validation.status}.`,
+        elapsed_ms: Date.now() - context.startedAt,
+    });
+    writeHumanProgress(context, `Moda Analyst (remote): validation ${validation.status}.`);
+    const written = [
+        ...writeHarnessReportArtifacts({
+            rootDir,
+            report,
+            validation,
+            markdown: context.flags.summary === 'true' || context.outputMode === 'human',
+        }),
+    ];
+    if (validation.status === 'pass') {
+        written.push(...writeHarnessArtifacts(report.graph, rootDir, {
+            summary: context.flags.summary === 'true',
+        }));
+    }
+    emitWrittenArtifacts(context, written, 'Written by Moda Analyst (remote).');
+    writeHarnessAnalyzeResult(context, {
+        scanPlan: options.scanPlan,
+        summary: validation.status === 'pass'
+            ? summarizeHarness(report.graph)
+            : summarizeInvalidAnalystReport(report),
+        report,
+        validation,
+        written,
+        dryRun: false,
+    });
+    return { exitCode: validation.status === 'pass' ? 0 : 1 };
+}
+/** Map CLI flags to the optional server-side analyze options in the wire contract. */
+function buildRemoteAnalyzeOptions(flags) {
+    const options = {};
+    const analyst = flags.analyst;
+    if (analyst === 'claude' || analyst === 'codex' || analyst === 'cursor' || analyst === 'auto') {
+        options.agent = analyst;
+    }
+    const shards = Number(flags.shards);
+    if (Number.isFinite(shards) && shards > 0)
+        options.shards = Math.floor(shards);
+    return Object.keys(options).length > 0 ? options : undefined;
+}
+async function postRemoteAnalyze(ingestUrl, apiKey, body) {
+    const parsed = await remoteAnalyzeFetch(`${ingestUrl}/v1/harness/analyze`, apiKey, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body),
+    }, REMOTE_UPLOAD_TIMEOUT_MS);
+    if (!parsed || parsed.success !== true || typeof parsed.analysis_run_id !== 'string' || parsed.analysis_run_id.length === 0) {
+        throw new CliInputError('Moda did not accept the harness analysis request.', 'The ingest worker returned an unexpected response. Retry, or run `moda harness analyze --analyst=local-scan`.');
+    }
+    return parsed;
+}
+async function pollRemoteAnalyze(options) {
+    const { ingestUrl, apiKey, runId, context } = options;
+    const timeoutMs = numericEnv('MODA_HARNESS_REMOTE_TIMEOUT_MS', DEFAULT_REMOTE_ANALYZE_TIMEOUT_MS);
+    const initialMs = numericEnvAllowZero('MODA_HARNESS_REMOTE_POLL_INITIAL_MS', DEFAULT_REMOTE_POLL_INITIAL_MS);
+    const maxMs = numericEnvAllowZero('MODA_HARNESS_REMOTE_POLL_MAX_MS', DEFAULT_REMOTE_POLL_MAX_MS);
+    const deadline = Date.now() + timeoutMs;
+    const url = `${ingestUrl}/v1/harness/analyze/${encodeURIComponent(runId)}`;
+    // Floor the inter-poll delay so a 0 (or unset) interval can't turn a long
+    // hosted run into a tight loop hammering the status endpoint.
+    const capMs = Math.max(maxMs, MIN_REMOTE_POLL_DELAY_MS);
+    let delay = Math.min(Math.max(initialMs, MIN_REMOTE_POLL_DELAY_MS), capMs);
+    let last = { success: false, status: 'accepted' };
+    while (true) {
+        last = await remoteAnalyzeFetch(url, apiKey, { method: 'GET' }, REMOTE_STATUS_TIMEOUT_MS);
+        if (last?.status === 'completed' || last?.status === 'failed')
+            return last;
+        const remaining = deadline - Date.now();
+        if (remaining <= 0)
+            return last ?? { success: false, status: 'running' };
+        context.output.writeEvent({
+            event: 'progress',
+            phase: 'remote_wait',
+            message: `Server-side analysis status: ${last?.status ?? 'running'}.`,
+            elapsed_ms: Date.now() - context.startedAt,
+        });
+        await sleep(Math.min(delay, remaining));
+        delay = Math.min(delay * 2, capMs);
+    }
+}
+async function remoteAnalyzeFetch(url, apiKey, init, timeoutMs) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    let response;
+    try {
+        response = await fetch(url, {
+            ...init,
+            headers: { Authorization: `Bearer ${apiKey}`, ...(init.headers ?? {}) },
+            signal: controller.signal,
+        });
+    }
+    catch (error) {
+        const isAbort = error instanceof DOMException && error.name === 'AbortError';
+        throw new CliInputError(isAbort
+            ? `Remote harness analysis request timed out after ${timeoutMs}ms.`
+            : `Network error reaching Moda ingest: ${error instanceof Error ? error.message : String(error)}.`, 'Check your connection and MODA_INGEST_URL, then retry `moda harness analyze --remote`.');
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+    if (!response.ok) {
+        const text = await response.text().catch(() => '');
+        throw new CliInputError(`Remote harness analysis request failed (HTTP ${response.status}).`, text ? truncateText(text, 500) : 'Retry, or run `moda harness analyze --analyst=local-scan`.');
+    }
+    return response.json();
+}
+//# sourceMappingURL=harness-remote.js.map

package/dist/harness.d.ts

@@ -1,4 +1,5 @@
 import type { CommandContext } from './command-context.js';
+import type { HarnessReport } from './harness-report.js';
 declare const SCHEMA_VERSION = "harness.v0.1";
 export interface HarnessEvidence {
     path: string;
@@ -228,6 +229,30 @@ export type CodingAgentMode = 'read-only' | 'write';
 export declare function runHarnessCommand(context: CommandContext): Promise<{
     exitCode: number;
 }>;
+/** Scan plan (scope, approval, read plan) built for every harness command run. */
+export type HarnessCommandScanPlan = ReturnType<typeof buildCommandScanPlan>;
+interface HarnessAnalyzePayload {
+    scanPlan: HarnessCommandScanPlan;
+    summary: HarnessSummary | Record<string, unknown>;
+    report: unknown;
+    validation: {
+        status: string;
+        warnings?: unknown[];
+        errors?: unknown[];
+    };
+    written: string[];
+    dryRun: boolean;
+}
+export declare function writeHarnessAnalyzeResult(context: CommandContext, payload: HarnessAnalyzePayload): void;
+/**
+ * Emit one `artifact` lifecycle event per written file, classifying report vs
+ * graph artifacts. Shared by the local-scan, external-analyst, and remote
+ * analyze paths.
+ */
+export declare function emitWrittenArtifacts(context: CommandContext, written: string[], description: string): void;
+export declare function repairExternalAnalystReport(report: HarnessReport, rootDir: string): HarnessReport;
+export declare function sleep(ms: number): Promise<void>;
+export declare function summarizeInvalidAnalystReport(report: unknown): Record<string, unknown>;
 export type CodingAgentAdapter = ExternalHarnessAnalystAdapter;
 export interface CodingAgentRun {
     adapter: CodingAgentAdapter;
@@ -256,9 +281,59 @@ export declare function runCodingAgent(options: {
     progressToStderr?: boolean;
     onProgress?: (message: string, phase?: string) => void;
 }): Promise<CodingAgentRun>;
+export declare function truncateText(value: string, maxLength: number): string;
 export declare function scanHarness(options?: ScanOptions): HarnessGraph;
 export declare function summarizeHarness(graph: HarnessGraph): HarnessSummary;
+/** One repo-relative source file included in a {@link SourceSnapshot}. */
+export interface SourceSnapshotFile {
+    path: string;
+    text: string;
+}
+/**
+ * A safe, bounded source snapshot uploaded to Moda for server-side ("Moda-hosted")
+ * harness analysis. Built by reusing the same permissioned inventory the local
+ * scanner uses, so it inherits every safety property already implemented in
+ * `inventoryFiles`: secret-bearing files are skipped, symlinks are skipped, and
+ * the per-file (512KB) plus whole-scan (12k-file / 48MB) budgets bound the size.
+ * Only files whose text was actually read are included; `truncated` records
+ * whether any file was dropped for exceeding a size/budget cap.
+ */
+export interface SourceSnapshot {
+    repo: {
+        name: string;
+        root: '.';
+    };
+    files: SourceSnapshotFile[];
+    truncated: boolean;
+    fileCount: number;
+    byteCount: number;
+    gitCommit?: string;
+}
+/**
+ * Build a safe source snapshot of `rootDir` by reusing the permissioned
+ * `inventoryFiles` walk (secret-skip, symlink-skip, 512KB/file, 12k-file/48MB
+ * caps) plus `detectRepo`/`getGitCommit`. Only files with text content are
+ * included; `truncated` is set when the scan dropped any file for a size/budget
+ * cap so the server knows the snapshot is incomplete.
+ */
+export declare function buildSourceSnapshot(rootDir: string): SourceSnapshot;
+declare function buildCommandScanPlan(context: CommandContext, rootDir: string): {
+    scope: 'broad' | 'narrow';
+    root: string;
+    approval: {
+        required: boolean;
+        granted: boolean;
+        reason: string;
+    };
+    readPlan: HarnessScanReadPlan;
+};
+export declare function writeHumanProgress(context: CommandContext, message: string): void;
 export declare function readHarnessSyncState(rootDir: string): HarnessSyncState | undefined;
+export declare function writeHarnessArtifacts(graph: HarnessGraph, rootDir: string, options?: {
+    summary?: boolean;
+}): string[];
 export declare function graphForSync(graph: HarnessGraph): HarnessGraph;
+export declare function numericEnv(name: string, fallback: number): number;
+export declare function numericEnvAllowZero(name: string, fallback: number): number;
 export {};
 //# sourceMappingURL=harness.d.ts.map

package/dist/harness.js

@@ -8,6 +8,7 @@ import { callControlAPI } from './api-client.js';
 import { AnalystTui, shouldUseAnalystTui } from './analyst-tui.js';
 import { resolveApiKey, resolveTenantId } from './config.js';
 import { CliInputError, CliInputRequiredError } from './errors.js';
+import { isRemoteHarnessAnalyze, runRemoteHarnessAnalyst } from './harness-remote.js';
 import { getActiveProfile } from './profiles.js';
 import { approveHarnessReport, createHarnessReport, graphForReport, hashHarnessReport, hashStableJson as hashHarnessReportStableJson, HARNESS_REPORT_PATH, loadHarnessReportForSync, normalizeHarnessReport, readHarnessReport, resolveHarnessReportPath, validateHarnessReport, writeHarnessReportArtifacts, } from './harness-report.js';
 import { renderHarnessAnalystChoice, renderHarnessAnalystLaunch, renderHarnessAnalystPreflight, renderHarnessAnalyzeHumanResult, renderHarnessProgress, } from './tui.js';
@@ -250,6 +251,9 @@ export async function runHarnessCommand(context) {
                 message: 'Starting Moda Analyst harness analysis.',
                 elapsed_ms: Date.now() - context.startedAt,
             });
+            if (isRemoteHarnessAnalyze(context)) {
+                return runRemoteHarnessAnalyst({ context, rootDir, scanPlan, tenant });
+            }
             const analyst = await resolveHarnessAnalystAdapter(context);
             if (analyst !== 'local-scan') {
                 return runExternalHarnessAnalyst({
@@ -308,20 +312,7 @@ export async function runHarnessCommand(context) {
                         summary: context.flags.summary === 'true',
                     }),
                 ];
-            for (const file of written) {
-                context.output.writeEvent({
-                    event: 'artifact',
-                    phase: 'write',
-                    artifact: {
-                        kind: file.includes('harness-report') || file.includes('HARNESS_REPORT')
-                            ? 'harness_report_artifact'
-                            : 'harness_graph_artifact',
-                        path: file,
-                        description: 'Written by Moda Analyst.',
-                    },
-                    elapsed_ms: Date.now() - context.startedAt,
-                });
-            }
+            emitWrittenArtifacts(context, written, 'Written by Moda Analyst.');
             writeHarnessAnalyzeResult(context, {
                 scanPlan,
                 summary: summarizeHarness(graph),
@@ -449,7 +440,7 @@ export async function runHarnessCommand(context) {
             throw new CliInputError(`Unknown harness command '${subcommand}'.`, 'Usage: moda harness analyze|validate-report|approve|scan|sync|agents|graph|explain|write-summary|status');
     }
 }
-function writeHarnessAnalyzeResult(context, payload) {
+export function writeHarnessAnalyzeResult(context, payload) {
     if (context.outputMode === 'human') {
         if (!context.quiet)
             console.log(renderHarnessAnalyzeHumanResult(payload));
@@ -504,6 +495,27 @@ function writeHarnessAnalyzeResult(context, payload) {
             ],
     });
 }
+/**
+ * Emit one `artifact` lifecycle event per written file, classifying report vs
+ * graph artifacts. Shared by the local-scan, external-analyst, and remote
+ * analyze paths.
+ */
+export function emitWrittenArtifacts(context, written, description) {
+    for (const file of written) {
+        context.output.writeEvent({
+            event: 'artifact',
+            phase: 'write',
+            artifact: {
+                kind: file.includes('harness-report') || file.includes('HARNESS_REPORT')
+                    ? 'harness_report_artifact'
+                    : 'harness_graph_artifact',
+                path: file,
+                description,
+            },
+            elapsed_ms: Date.now() - context.startedAt,
+        });
+    }
+}
 async function runExternalHarnessAnalyst(options) {
     if (options.context.dryRun) {
         throw new CliInputError('External harness analysis cannot run in dry-run mode yet.', 'Use `moda harness analyze --analyst=local-scan --dry-run` for deterministic fallback inspection.');
@@ -622,20 +634,7 @@ async function runExternalHarnessAnalyst(options) {
             }));
         }
         analystTui?.setArtifacts(written);
-        for (const file of written) {
-            options.context.output.writeEvent({
-                event: 'artifact',
-                phase: 'write',
-                artifact: {
-                    kind: file.includes('harness-report') || file.includes('HARNESS_REPORT')
-                        ? 'harness_report_artifact'
-                        : 'harness_graph_artifact',
-                    path: file,
-                    description: 'Written by Moda Analyst.',
-                },
-                elapsed_ms: Date.now() - options.context.startedAt,
-            });
-        }
+        emitWrittenArtifacts(options.context, written, 'Written by Moda Analyst.');
         analystTui?.complete(validation.status === 'pass' ? 'pass' : 'fail');
         analystTui?.stop();
         writeHarnessAnalyzeResult(options.context, {
@@ -726,7 +725,7 @@ function parseHarnessReportCandidate(candidate) {
     }
     return undefined;
 }
-function repairExternalAnalystReport(report, rootDir) {
+export function repairExternalAnalystReport(report, rootDir) {
     const normalized = normalizeHarnessReport(report);
     repairCitationLines(normalized, rootDir);
     repairReportSummaryCounts(normalized);
@@ -974,7 +973,7 @@ function externalAnalystMaxAttempts(adapter) {
     const defaultRetries = adapter === 'claude' ? 2 : 1;
     return 1 + numericEnvAllowZero('MODA_HARNESS_ANALYST_RETRIES', defaultRetries);
 }
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
 }
 function recordExternalAgentTextChunk(text, tui) {
@@ -1116,7 +1115,7 @@ function isRecord(value) {
 function stringValue(value) {
     return typeof value === 'string' && value.length > 0 ? value : undefined;
 }
-function summarizeInvalidAnalystReport(report) {
+export function summarizeInvalidAnalystReport(report) {
     if (!report || typeof report !== 'object')
         return { status: 'invalid_report' };
     const reportRecord = report;
@@ -1554,7 +1553,7 @@ function findOnPath(command) {
 function splitCommandLine(commandLine) {
     return commandLine.trim().split(/\s+/).filter(Boolean);
 }
-function truncateText(value, maxLength) {
+export function truncateText(value, maxLength) {
     const compact = value.replace(/\s+/g, ' ').trim();
     return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}...` : compact;
 }
@@ -1618,6 +1617,62 @@ export function summarizeHarness(graph) {
         unknownCount: graph.unknowns.length,
     };
 }
+/** Skip reasons that mean a file was dropped for exceeding a size/budget cap. */
+function isSnapshotBudgetSkip(reason) {
+    return reason === 'file too large for harness scan' ||
+        reason === 'scan text budget exceeded';
+}
+/**
+ * Serialized-file budget for a {@link SourceSnapshot}, kept under the ingest
+ * proxy's 5MB request-body cap (`MAX_ANALYZE_BODY_BYTES` in
+ * apps/moda-ingest-worker) with ~500KB of headroom for the JSON envelope. The
+ * raw inventory text budget (48MB) is far larger, so this is the binding limit.
+ */
+const MAX_SNAPSHOT_BODY_BYTES = 4_500_000;
+/**
+ * Build a safe source snapshot of `rootDir` by reusing the permissioned
+ * `inventoryFiles` walk (secret-skip, symlink-skip, 512KB/file, 12k-file/48MB
+ * caps) plus `detectRepo`/`getGitCommit`. Only files with text content are
+ * included; `truncated` is set when the scan dropped any file for a size/budget
+ * cap so the server knows the snapshot is incomplete.
+ */
+export function buildSourceSnapshot(rootDir) {
+    const root = resolve(rootDir);
+    const skipped = [];
+    const files = inventoryFiles(root, skipped);
+    const repo = detectRepo(root, files);
+    const includedFiles = [];
+    let byteCount = 0;
+    let serializedBytes = 0;
+    let truncatedBySize = false;
+    for (const item of files) {
+        if (item.text === undefined)
+            continue;
+        const file = { path: item.path, text: item.text };
+        // Bound the SERIALIZED upload, not just the raw inventory text: the ingest
+        // proxy caps the request body at MAX_ANALYZE_BODY_BYTES (5MB) while the
+        // inventory text budget (48MB) is far larger. Account for JSON encoding
+        // (keys, quotes, escaping, and the array comma) so a large repo produces a
+        // `truncated` snapshot that still uploads instead of failing with HTTP 413.
+        const cost = Buffer.byteLength(JSON.stringify(file), 'utf8') + 1;
+        if (serializedBytes + cost > MAX_SNAPSHOT_BODY_BYTES) {
+            truncatedBySize = true;
+            break;
+        }
+        includedFiles.push(file);
+        serializedBytes += cost;
+        byteCount += Buffer.byteLength(item.text, 'utf8');
+    }
+    const gitCommit = getGitCommit(root);
+    return {
+        repo: { name: repo.name, root: '.' },
+        files: includedFiles,
+        truncated: truncatedBySize || skipped.some((skip) => isSnapshotBudgetSkip(skip.reason)),
+        fileCount: includedFiles.length,
+        byteCount,
+        ...(gitCommit ? { gitCommit } : {}),
+    };
+}
 function buildCommandScanPlan(context, rootDir) {
     const explicitPath = context.flags.path !== undefined;
     const rel = normalizePath(relative(context.cwd, rootDir)) || '.';
@@ -1675,7 +1730,7 @@ async function approveScanIfNeeded(scanPlan, options = {}) {
         throw new CliInputError(options.declinedMessage ?? 'Harness scan was not approved.', options.declinedHint ?? 'Run `moda harness scan --path=<dir>` for a narrower scan, or rerun with `--yes` after reviewing the read plan.');
     }
 }
-function writeHumanProgress(context, message) {
+export function writeHumanProgress(context, message) {
     if (context.outputMode !== 'human')
         return;
     if (context.quiet && context.flags.progress !== 'true')
@@ -1854,7 +1909,7 @@ function loadOrScanHarness(rootDir, tenant) {
 function readHarnessGraph(manifestPath) {
     return JSON.parse(readFileSync(manifestPath, 'utf8'));
 }
-function writeHarnessArtifacts(graph, rootDir, options = {}) {
+export function writeHarnessArtifacts(graph, rootDir, options = {}) {
     const modaDir = join(rootDir, MODA_DIR);
     mkdirSync(modaDir, { recursive: true });
     const manifestPath = join(rootDir, HARNESS_PATH);
@@ -2168,14 +2223,14 @@ function throwHarnessScanTooBroad(rootDir, details) {
         'For harness-only analysis, use `moda harness analyze --path=<agent-dir> --summary`.',
     ].join('\n'));
 }
-function numericEnv(name, fallback) {
+export function numericEnv(name, fallback) {
     const raw = process.env[name];
     if (!raw)
         return fallback;
     const parsed = Number(raw);
     return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : fallback;
 }
-function numericEnvAllowZero(name, fallback) {
+export function numericEnvAllowZero(name, fallback) {
     const raw = process.env[name];
     if (!raw)
         return fallback;
@@ -2426,14 +2481,19 @@ function environmentFromAnnotation(annotation) {
     };
 }
 function applyHeuristics(graph, files) {
+    const isApplicationCode = applicationCodePredicate(files);
     for (const file of files) {
         maybeAddPromptArtifact(graph, file);
         maybeAddSkillArtifact(graph, file);
+        if (isApplicationCode(file.path))
+            maybeAddToolArtifact(graph, file);
         maybeAddEvalArtifact(graph, file);
         maybeAddDeployment(graph, file);
     }
     if (graph.runtimeAgents.length === 0) {
         for (const file of files) {
+            if (!isApplicationCode(file.path))
+                continue;
             const agent = inferRuntimeAgent(file, graph);
             if (agent)
                 upsertRuntimeAgent(graph, agent);
@@ -2532,7 +2592,10 @@ function inferRuntimeAgent(file, graph) {
     const loweredText = file.text.toLowerCase();
     const pathLooksLikeAgent = /(^|\/)(agent|agents|agent_harness)\//.test(loweredPath) ||
         /(^|\/)(agent|main|index)\.(ts|tsx|js|mjs|py)$/.test(loweredPath);
-    const codeLooksLikeAgent = /\b(run_agent|runagent|createagent|buildprompt|system prompt|openai|anthropic|model)\b/i.test(file.text);
+    // Require evidence that the file actually constructs or runs an agent, not
+    // merely that it mentions a model provider. Loose signals like "openai" or
+    // "model" match library internals and utilities that are not runtime agents.
+    const codeLooksLikeAgent = AGENT_RUNTIME_SIGNAL.test(file.text);
     if (!pathLooksLikeAgent || !codeLooksLikeAgent)
         return null;
     const channelIds = inferChannels(file);
@@ -2618,16 +2681,136 @@ function inferChannels(file) {
         .filter(([needle]) => text.includes(needle))
         .map(([, id]) => id);
 }
+// Trailing module names an import statement references, normalized to their last
+// path segment without extension. Covers ES/TS `from '...'` / `import(...)` /
+// `require(...)` and Python `from a.b.c import ...` / `import a.b.c`. Used to link
+// split-file tools whose module is imported by extensionless or dotted name
+// (e.g. `from tools import get_weather`, `import { getWeather } from './tools'`).
+function importedModuleNames(text) {
+    const names = new Set();
+    for (const match of text.matchAll(/(?:from|import|require)\s*\(?\s*["']([^"']+)["']/g)) {
+        const segment = match[1].split('/').pop();
+        if (segment)
+            names.add(segment.replace(/\.(ts|tsx|js|mjs|py)$/i, ''));
+    }
+    for (const match of text.matchAll(/^\s*(?:from|import)\s+([.\w]+)/gm)) {
+        const segment = match[1].replace(/^\.+/, '').split('.').pop();
+        if (segment)
+            names.add(segment);
+    }
+    return names;
+}
 function inferArtifactsForFile(file, graph) {
     const text = file.text ?? '';
+    const imported = importedModuleNames(text);
     const referenced = graph.artifacts.filter((artifact) => {
         if (!artifact.sourcePath)
             return false;
+        if (artifact.sourcePath === file.path)
+            return true;
         const base = basename(artifact.sourcePath);
-        return text.includes(base) || text.includes(artifact.sourcePath);
+        if (text.includes(base) || text.includes(artifact.sourcePath))
+            return true;
+        // Split-file tools: the agent imports the tool module by its extensionless or
+        // dotted name, which contains neither the basename-with-extension nor the full
+        // source path (e.g. `from tools import get_weather`, `from './tools'`).
+        if (artifact.type === 'tool') {
+            const moduleName = base.replace(/\.(ts|tsx|js|mjs|py)$/i, '');
+            if (moduleName && imported.has(moduleName))
+                return true;
+        }
+        return false;
     });
     return referenced.map((artifact) => artifact.id);
 }
+// Signals that a file constructs or runs an agent (as opposed to merely
+// importing a model SDK). Kept deliberately construction/run oriented so
+// library internals that only reference a provider are not misread as agents.
+// Covers the LangChain factory/executor shapes (create_tool_calling_agent,
+// create_openai_functions_agent, AgentExecutor, ...) and the `return`/`yield
+// Agent(...)` factory forms in addition to the direct construction/run signals.
+const AGENT_RUNTIME_SIGNAL = /(run_agent|runAgent|create_[a-z_]*agent\b|createAgent|initialize_agent|AgentExecutor\s*\(|new\s+Agent\s*\(|\bSwarm\s*\(|\bCrew\s*\(|\bRunner\s*\(|Runner\.run|\.run_sync\s*\(|\.run_streamed\s*\(|[=([,]\s*Agent\s*\(|(?:return|yield)\s+Agent\s*\(|^\s*Agent\s*\()/im;
+// Hosted/first-party tool classes that count as tool definitions when called.
+const HOSTED_TOOL_CLASSES = [
+    'WebSearchTool',
+    'FileSearchTool',
+    'ComputerTool',
+    'CodeInterpreterTool',
+    'HostedMCPTool',
+    'ImageGenerationTool',
+    'LocalShellTool',
+    'ShellTool',
+    'ApplyPatchTool',
+    'FunctionTool',
+];
+function repoOwnPackageNames(files) {
+    const packageJson = files.find((file) => file.path === 'package.json')?.text;
+    const pyproject = files.find((file) => file.path === 'pyproject.toml')?.text;
+    const names = [
+        packageJson ? safePackageName(packageJson) : undefined,
+        pyproject ? safeTomlName(pyproject) : undefined,
+    ];
+    return names.filter((name) => Boolean(name)).map((name) => name.toLowerCase());
+}
+function repoIsAgentFrameworkSource(files) {
+    const own = new Set(repoOwnPackageNames(files));
+    if (own.size === 0)
+        return false;
+    return FRAMEWORK_CATALOG.some((framework) => framework.packageNames.some((name) => own.has(name.toLowerCase())));
+}
+function isApplicationLikePath(path) {
+    return /(^|\/)(examples?|apps?|demos?|samples?|cookbook|tutorials?|quickstart|playground)\//i.test(path);
+}
+// When the repository IS an agent framework/SDK (its own package name matches a
+// framework catalog entry), its library source is the framework implementation,
+// not customer application code: runtime agents and tools should only be
+// inferred from application-like directories (examples, apps, demos, ...).
+function applicationCodePredicate(files) {
+    return repoIsAgentFrameworkSource(files) ? isApplicationLikePath : () => true;
+}
+const HOSTED_TOOL_CALL = new RegExp(`\\b(${HOSTED_TOOL_CLASSES.join('|')})\\s*\\(`, 'g');
+function detectToolDefinitions(file) {
+    const text = file.text;
+    if (!text)
+        return [];
+    const found = new Map();
+    const pyDecorated = /@function_tool[^\n]*\n(?:[ \t]*@[^\n]*\n)*[ \t]*(?:async[ \t]+)?def[ \t]+([A-Za-z_]\w*)/g;
+    for (const match of text.matchAll(pyDecorated))
+        found.set(match[1], '@function_tool-decorated function');
+    const tsFactory = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:[\w.]*\.)?(?:tool|functionTool|createTool|dynamicTool)\s*\(/g;
+    for (const match of text.matchAll(tsFactory))
+        found.set(match[1], 'tool factory assignment');
+    const tsNewTool = /(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*new\s+(?:Dynamic|Structured)?Tool\b/g;
+    for (const match of text.matchAll(tsNewTool))
+        found.set(match[1], 'tool constructor assignment');
+    for (const match of text.matchAll(HOSTED_TOOL_CALL))
+        found.set(match[1], `hosted tool ${match[1]}`);
+    return [...found.entries()].map(([name, reason]) => ({ name, reason }));
+}
+function maybeAddToolArtifact(graph, file) {
+    if (!/\.(ts|tsx|js|mjs|py)$/i.test(file.path))
+        return;
+    // Skip test/eval fixtures — those tool definitions are fixtures, not a
+    // customer's runtime tools. (Framework library internals are already
+    // excluded by applyHeuristics's application-code predicate.)
+    if (isEvalLikePath(file.path))
+        return;
+    const tools = detectToolDefinitions(file);
+    if (tools.length === 0)
+        return;
+    for (const tool of tools) {
+        upsertArtifact(graph, {
+            id: stableId('tool', `${file.path}:${tool.name}`),
+            type: 'tool',
+            name: titleFromId(tool.name),
+            scope: 'agent',
+            sourcePath: file.path,
+            usedByAgentIds: [],
+            confidence: 0.6,
+            evidence: [{ path: file.path, reason: `Tool definition detected (${tool.reason}).` }],
+        });
+    }
+}
 function detectDeveloperAgentAdapters(files) {
     const adapters = [];
     if (files.some((file) => file.path.startsWith('.claude/'))) {
@@ -2690,7 +2873,7 @@ const FRAMEWORK_CATALOG = [
         name: 'LangChain',
         kind: 'agent_framework',
         packageNames: ['langchain', '@langchain/core', '@langchain/langgraph', 'langgraph'],
-        patterns: [/langchain/i, /langgraph/i],
+        patterns: [/\blangchain\b/i, /\blanggraph\b/i],
     },
     {
         id: 'framework_vercel_ai_sdk',
@@ -2704,7 +2887,7 @@ const FRAMEWORK_CATALOG = [
         name: 'Mastra',
         kind: 'agent_framework',
         packageNames: ['mastra', '@mastra/core'],
-        patterns: [/mastra/i],
+        patterns: [/\bmastra\b/i],
     },
     {
         id: 'framework_openai_agents',
@@ -2718,7 +2901,7 @@ const FRAMEWORK_CATALOG = [
         name: 'CrewAI',
         kind: 'agent_framework',
         packageNames: ['crewai'],
-        patterns: [/crewai/i],
+        patterns: [/\bcrewai\b/i],
     },
     {
         id: 'framework_pydantic_ai',
@@ -2743,7 +2926,7 @@ const PROVIDER_CATALOG = [
         kind: 'model_provider',
         packageNames: ['@anthropic-ai/sdk', '@ai-sdk/anthropic', 'anthropic'],
         envVars: ['ANTHROPIC_API_KEY'],
-        patterns: [/anthropic/i, /\bclaude-[\w.-]+/i, /ANTHROPIC_API_KEY/],
+        patterns: [/\banthropic\b/i, /\bclaude-[\w.-]+/i, /ANTHROPIC_API_KEY/],
     },
     {
         id: 'provider_google',
@@ -2751,7 +2934,7 @@ const PROVIDER_CATALOG = [
         kind: 'model_provider',
         packageNames: ['@google/generative-ai', '@ai-sdk/google', 'google-generativeai'],
         envVars: ['GOOGLE_GENERATIVE_AI_API_KEY', 'GEMINI_API_KEY'],
-        patterns: [/gemini/i, /google.generativeai/i],
+        patterns: [/\bgemini\b/i, /google\.generativeai/i],
     },
     {
         id: 'provider_cohere',
@@ -2759,7 +2942,7 @@ const PROVIDER_CATALOG = [
         kind: 'model_provider',
         packageNames: ['cohere-ai', 'cohere'],
         envVars: ['COHERE_API_KEY'],
-        patterns: [/cohere/i],
+        patterns: [/\bcohere\b/i],
     },
     {
         id: 'provider_mistral',
@@ -2767,7 +2950,7 @@ const PROVIDER_CATALOG = [
         kind: 'model_provider',
         packageNames: ['@mistralai/mistralai', 'mistralai'],
         envVars: ['MISTRAL_API_KEY'],
-        patterns: [/mistral/i],
+        patterns: [/\bmistral\b/i],
     },
     {
         id: 'provider_ollama',
@@ -2775,7 +2958,7 @@ const PROVIDER_CATALOG = [
         kind: 'model_provider',
         packageNames: ['ollama'],
         envVars: ['OLLAMA_HOST'],
-        patterns: [/ollama/i],
+        patterns: [/\bollama\b/i],
     },
 ];
 function detectAgentFrameworks(files) {
@@ -2828,9 +3011,9 @@ function detectionEvidence(files, packageNames, patterns) {
             }
         }
         if (file.path === 'pyproject.toml' && file.text) {
-            const lowered = file.text.toLowerCase();
+            const deps = pyprojectDependencyNames(file.text);
             for (const name of packageNames) {
-                if (lowered.includes(name.toLowerCase())) {
+                if (deps.has(name.toLowerCase())) {
                     evidence.push({ path: file.path, reason: `Python dependency ${name} detected.` });
                 }
             }
@@ -2860,6 +3043,53 @@ function packageDependencyNames(text) {
         return new Set();
     }
 }
+function pyprojectDependencyNames(text) {
+    // Only extract names from actual dependency contexts, never every quoted string
+    // in the file: that would re-open the "ai"-inside-`keywords = ["ai"]` /
+    // `name = "openai-agents"` false positives this parser exists to avoid. Two
+    // dependency shapes are covered, and membership is tested by exact name:
+    //   - PEP 621 / PEP 518 requirement arrays (`dependencies`/`requires = [...]`,
+    //     `[project.optional-dependencies]`, `[dependency-groups]`): leading
+    //     distribution token of each quoted PEP 508 string (e.g. "openai>=2" -> openai).
+    //   - Poetry tables (`[tool.poetry.dependencies]`, `dev-dependencies`,
+    //     `group.<name>.dependencies`): the bare TOML key (e.g. `openai = "^1.0"`).
+    const names = new Set();
+    const addLeadingToken = (spec) => {
+        const match = spec.match(/^\s*([A-Za-z0-9][A-Za-z0-9._-]*)/);
+        if (match)
+            names.add(match[1].toLowerCase());
+    };
+    const isPoetryDepTable = (section) => /^tool\.poetry\.(dependencies|dev-dependencies|group\.[^.]+\.dependencies)$/.test(section);
+    const isRequirementArrayTable = (section) => section === 'project.optional-dependencies' || section === 'dependency-groups';
+    let section = '';
+    let inDependencyArray = false;
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.split('#')[0];
+        const header = line.match(/^\s*\[\[?\s*([^\]]+?)\s*\]\]?\s*$/);
+        if (header) {
+            section = header[1].trim().toLowerCase();
+            inDependencyArray = false;
+            continue;
+        }
+        if (/^\s*(?:dependencies|requires)\s*=\s*\[/.test(line) ||
+            (isRequirementArrayTable(section) && /=\s*\[/.test(line))) {
+            inDependencyArray = true;
+        }
+        if (inDependencyArray) {
+            for (const match of line.matchAll(/["']([^"']+)["']/g))
+                addLeadingToken(match[1]);
+            if (line.includes(']'))
+                inDependencyArray = false;
+            continue;
+        }
+        if (isPoetryDepTable(section)) {
+            const key = line.match(/^\s*([A-Za-z0-9][A-Za-z0-9._-]*)\s*=/);
+            if (key && key[1].toLowerCase() !== 'python')
+                names.add(key[1].toLowerCase());
+        }
+    }
+    return names;
+}
 function modelHintsForProvider(providerId, files) {
     const hints = new Set();
     const pattern = providerId === 'provider_anthropic'

package/dist/init/index.js

@@ -86,9 +86,16 @@ export async function runInit(flags, options = {}) {
     log(renderInitNote(`Active workspace: ${tenantName}`));
     emit('workspace', `Active workspace: ${tenantName}`, 'completed');
     phases.push({ id: 'workspace', title: 'Workspace & Profile', status: 'completed', details: tenantName });
-    // Step 4: Harness analyst report.
-    log(renderInitStep(4, 7, 'Harness Discovery', 'Moda Analyst investigates the harness and writes cited local artifacts.'));
-    emit('harness', 'Running Moda Analyst harness discovery.');
+    // Step 4: Harness analyst report. When the user passes `--remote`, Moda runs
+    // the analyst server-side (uploading a safe source snapshot) so no local
+    // coding agent is required; otherwise the local analyst runs as before.
+    const remote = isTruthyFlag(flagValue(flags, 'remote'));
+    log(renderInitStep(4, 7, 'Harness Discovery', remote
+        ? 'Moda runs the harness analyst server-side and writes cited local artifacts.'
+        : 'Moda Analyst investigates the harness and writes cited local artifacts.'));
+    emit('harness', remote
+        ? 'Running Moda-hosted harness discovery.'
+        : 'Running Moda Analyst harness discovery.');
     const harnessResult = await runHarnessCommand(createCommandContext({
         command: 'harness',
         positional: 'analyze',
@@ -104,6 +111,7 @@ export async function runInit(flags, options = {}) {
             json: json || agent,
             agent,
             analyst: stringFlag(flags.analyst) ?? 'auto',
+            remote,
             quiet: true,
             progress: true,
             'no-telemetry': true,
@@ -616,7 +624,9 @@ function parseOptionalBoolean(value) {
     return undefined;
 }
 function isTruthyFlag(value) {
-    return value === true || value === 'true' || value === '1' || value === 'yes';
+    // The CLI normalizes numeric-looking flag values to numbers (`--remote=1` →
+    // number 1), so accept the numeric `1` alongside the string spellings.
+    return value === true || value === 1 || value === 'true' || value === '1' || value === 'yes';
 }
 function flagValue(flags, ...keys) {
     for (const key of keys) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moda-ai/cli",
-  "version": "1.12.0",
+  "version": "1.12.3",
   "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-06T02:25:00.333Z",
-  "cli_version": "1.12.0",
+  "bundled_at": "2026-07-06T05:27:59.799Z",
+  "cli_version": "1.12.3",
   "skills": [
     {
       "id": "integration-node-anthropic",