@moda-ai/cli 1.12.0 → 1.12.2

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;

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.2",
   "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-06T03:50:30.586Z",
+  "cli_version": "1.12.2",
   "skills": [
     {
       "id": "integration-node-anthropic",