@moda-ai/cli 1.1.1 → 1.2.0

package/dist/harness.js

@@ -0,0 +1,3264 @@
+import { createHash } from 'node:crypto';
+import { execFileSync, spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
+import { basename, delimiter, dirname, extname, join, relative, resolve, sep } from 'node:path';
+import { confirm, select } from '@inquirer/prompts';
+import { callControlAPI } from './api-client.js';
+import { AnalystTui, shouldUseAnalystTui } from './analyst-tui.js';
+import { resolveApiKey, resolveTenantId } from './config.js';
+import { CliInputError } from './errors.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';
+const MODA_DIR = '.moda';
+const HARNESS_PATH = join(MODA_DIR, 'harness.json');
+const HARNESS_SUMMARY_PATH = join(MODA_DIR, 'HARNESS.md');
+const SYNC_STATE_PATH = join(MODA_DIR, 'sync-state.json');
+const SCHEMA_VERSION = 'harness.v0.1';
+const MAX_SCANNED_FILE_BYTES = 512 * 1024;
+const DEFAULT_MAX_INVENTORY_FILES = 12_000;
+const DEFAULT_MAX_INVENTORY_TEXT_BYTES = 48 * 1024 * 1024;
+const MAX_RECORDED_SKIPS = 1_000;
+const REPORT_JSON_BEGIN = 'MODA_HARNESS_REPORT_JSON_BEGIN';
+const REPORT_JSON_END = 'MODA_HARNESS_REPORT_JSON_END';
+const SKIPPED_DIRS = new Set([
+    '.angular',
+    '.cache',
+    '.expo',
+    '.git',
+    '.hg',
+    '.idea',
+    '.svn',
+    '.next',
+    '.nuxt',
+    '.output',
+    '.parcel-cache',
+    '.pytest_cache',
+    '.ruff_cache',
+    '.serverless',
+    '.sst',
+    '.turbo',
+    '.wrangler',
+    '.wrangler-shared',
+    '.moda',
+    '.moda-test',
+    '.moda-test-home',
+    '.moda-cli-workspaces',
+    '.moda-cli-benchmarks',
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    'out',
+    'target',
+    'logs',
+    'tmp',
+    'temp',
+    '__pycache__',
+    '.venv',
+    'venv',
+]);
+const SKIPPED_PATH_PREFIXES = [
+    '.claude/worktrees',
+    '.codex/environments',
+];
+const EXTERNAL_ANALYST_ADAPTERS = ['claude', 'codex', 'cursor'];
+export async function runHarnessCommand(context) {
+    const subcommand = context.positionals[0] ?? 'scan';
+    const rootDir = resolve(context.cwd, context.flags.path ?? '.');
+    const selectedAgentId = selectedRuntimeAgentId(context.flags);
+    const tenant = resolveHarnessTenant(context.flags, context);
+    const scanPlan = buildCommandScanPlan(context, rootDir);
+    switch (subcommand) {
+        case 'scan': {
+            await approveScanIfNeeded(scanPlan, { context });
+            writeHumanProgress(context, 'Harness scan: inventorying local files...');
+            const graph = scanHarness({
+                rootDir,
+                dryRun: context.dryRun,
+                tenantId: tenant?.tenantId,
+                tenantSource: tenant?.source,
+                pathWasExplicit: context.flags.path !== undefined,
+            });
+            const written = context.dryRun ? [] : writeHarnessArtifacts(graph, rootDir, {
+                summary: context.flags.summary === 'true',
+            });
+            writeHumanProgress(context, 'Harness scan: complete.');
+            context.output.writeData({
+                scanPlan,
+                summary: summarizeHarness(graph),
+                graph,
+                written,
+                dryRun: context.dryRun,
+            });
+            return { exitCode: 0 };
+        }
+        case 'sync': {
+            if (!resolveApiKey({ profile: context.profile, env: context.env }) && !context.dryRun) {
+                throw new CliInputError('No Moda API key found for harness sync.', 'Run `moda init` first, set MODA_API_KEY, or select a profile with an API key.');
+            }
+            if (context.flags['from-report'] || context.flags.report) {
+                const reportPath = resolveHarnessReportPath(rootDir, context.flags['from-report'] ?? context.flags.report);
+                const { report, validation, approval, approved } = loadHarnessReportForSync(rootDir, reportPath);
+                const reportHash = hashHarnessReport(report);
+                if (!approved && !context.dryRun) {
+                    throw new CliInputError('Harness report is not approved; refusing to sync.', 'Run `moda harness validate-report`, review the report, then run `moda harness approve --yes` before syncing.');
+                }
+                const syncGraph = graphForReport(report.graph);
+                const sourceCommit = report.source.sourceCommit ?? getGitCommit(rootDir);
+                const localGraphHash = hashHarnessReportStableJson(syncGraph);
+                const plan = createHarnessSyncPlan({
+                    context,
+                    rootDir,
+                    graph: report.graph,
+                    source: 'approved_report',
+                    sourceCommit,
+                    localGraphHash,
+                    localWrites: plannedHarnessArtifactWrites(context),
+                });
+                const written = context.dryRun ? [] : writeHarnessArtifacts(report.graph, rootDir, {
+                    summary: context.flags.summary === 'true',
+                });
+                const syncBody = {
+                    graph: syncGraph,
+                    graphHash: localGraphHash,
+                    sourceCommit,
+                    report,
+                    reportHash,
+                    reportValidationStatus: validation.status,
+                    reportApproval: approval ? {
+                        approved: approval.approved,
+                        approvedAt: approval.approvedAt,
+                        approvedBy: approval.approvedBy,
+                        reportHash: approval.reportHash,
+                    } : undefined,
+                };
+                const response = await syncHarnessWithRemote(context, syncBody);
+                const statePath = response && !context.dryRun
+                    ? writeHarnessSyncState(rootDir, {
+                        schemaVersion: 'sync_state.v0.1',
+                        updatedAt: new Date().toISOString(),
+                        resource: 'harness',
+                        source: 'approved_report',
+                        profile: plan.profile,
+                        tenantId: response.tenantId ?? plan.tenantId,
+                        rootPath: plan.rootPath,
+                        sourceCommit,
+                        harnessId: report.graph.harnessId,
+                        localGraphHash,
+                        report: {
+                            reportId: report.reportId,
+                            reportHash,
+                            validationStatus: validation.status,
+                        },
+                        remote: response,
+                        summary: summarizeHarness(report.graph),
+                        uploads: plan.uploads,
+                        privacy: plan.privacy,
+                        written,
+                    })
+                    : undefined;
+                context.output.writeData({
+                    plan,
+                    report: {
+                        reportId: report.reportId,
+                        reportHash,
+                        path: normalizePath(relative(rootDir, reportPath)) || '.moda/harness-report.json',
+                    },
+                    validation,
+                    approval: {
+                        approved,
+                        approvedAt: approval?.approvedAt,
+                        approvedBy: approval?.approvedBy,
+                    },
+                    summary: summarizeHarness(report.graph),
+                    remote: response ?? plannedDryRunRemote(plan),
+                    written,
+                    syncState: statePath ? { path: statePath } : undefined,
+                    dryRun: context.dryRun,
+                });
+                return { exitCode: 0 };
+            }
+            const graph = scanHarness({
+                rootDir,
+                dryRun: context.dryRun,
+                tenantId: tenant?.tenantId,
+                tenantSource: tenant?.source,
+                pathWasExplicit: context.flags.path !== undefined,
+            });
+            const syncGraph = graphForSync(graph);
+            const sourceCommit = getGitCommit(rootDir);
+            const localGraphHash = hashStableJson(syncGraph);
+            const plan = createHarnessSyncPlan({
+                context,
+                rootDir,
+                graph,
+                source: 'local_scan',
+                sourceCommit,
+                localGraphHash,
+                localWrites: plannedHarnessArtifactWrites(context),
+            });
+            const written = context.dryRun ? [] : writeHarnessArtifacts(graph, rootDir, {
+                summary: context.flags.summary === 'true',
+            });
+            const response = await syncHarnessWithRemote(context, {
+                graph: syncGraph,
+                graphHash: localGraphHash,
+                sourceCommit,
+            });
+            const statePath = response && !context.dryRun
+                ? writeHarnessSyncState(rootDir, {
+                    schemaVersion: 'sync_state.v0.1',
+                    updatedAt: new Date().toISOString(),
+                    resource: 'harness',
+                    source: 'local_scan',
+                    profile: plan.profile,
+                    tenantId: response.tenantId ?? plan.tenantId,
+                    rootPath: plan.rootPath,
+                    sourceCommit,
+                    harnessId: graph.harnessId,
+                    localGraphHash,
+                    remote: response,
+                    summary: summarizeHarness(graph),
+                    uploads: plan.uploads,
+                    privacy: plan.privacy,
+                    written,
+                })
+                : undefined;
+            context.output.writeData({
+                scanPlan,
+                plan,
+                summary: summarizeHarness(graph),
+                remote: response ?? plannedDryRunRemote(plan),
+                written,
+                syncState: statePath ? { path: statePath } : undefined,
+                dryRun: context.dryRun,
+            });
+            return { exitCode: 0 };
+        }
+        case 'analyze': {
+            await approveScanIfNeeded(scanPlan, {
+                context,
+                message: 'Run Moda Analyst to investigate this project and produce a cited harness report?',
+                declinedMessage: 'Harness analysis was not approved.',
+                declinedHint: 'Run `moda harness analyze --path=<dir>` for a narrower investigation, or rerun with `--yes` after reviewing the read plan.',
+            });
+            context.output.writeEvent({
+                event: 'started',
+                phase: 'harness_analyze',
+                message: 'Starting Moda Analyst harness analysis.',
+                elapsed_ms: Date.now() - context.startedAt,
+            });
+            const analyst = await resolveHarnessAnalystAdapter(context);
+            if (analyst !== 'local-scan') {
+                return runExternalHarnessAnalyst({
+                    context,
+                    rootDir,
+                    scanPlan,
+                    tenant,
+                    adapter: analyst,
+                });
+            }
+            context.output.writeEvent({
+                event: 'progress',
+                phase: 'inventory',
+                message: 'Inventorying local harness files.',
+                elapsed_ms: Date.now() - context.startedAt,
+            });
+            writeHumanProgress(context, 'Moda Analyst: inventorying local harness files...');
+            const graph = scanHarness({
+                rootDir,
+                dryRun: context.dryRun,
+                tenantId: tenant?.tenantId,
+                tenantSource: tenant?.source,
+                pathWasExplicit: context.flags.path !== undefined,
+            });
+            context.output.writeEvent({
+                event: 'progress',
+                phase: 'report',
+                message: 'Producing cited structured harness report.',
+                elapsed_ms: Date.now() - context.startedAt,
+            });
+            writeHumanProgress(context, 'Moda Analyst: producing cited structured harness report...');
+            const report = createHarnessReport({
+                graph,
+                rootDir,
+                sourceCommit: getGitCommit(rootDir),
+                analystAdapter: 'local-scan',
+            });
+            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: validation ${validation.status}.`);
+            const written = context.dryRun
+                ? []
+                : [
+                    ...writeHarnessReportArtifacts({
+                        rootDir,
+                        report,
+                        validation,
+                        markdown: context.flags.summary === 'true' || context.outputMode === 'human',
+                    }),
+                    ...writeHarnessArtifacts(report.graph, rootDir, {
+                        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,
+                });
+            }
+            writeHarnessAnalyzeResult(context, {
+                scanPlan,
+                summary: summarizeHarness(graph),
+                report,
+                validation,
+                written,
+                dryRun: context.dryRun,
+            });
+            return { exitCode: validation.status === 'pass' ? 0 : 1 };
+        }
+        case 'validate-report': {
+            const reportPath = resolveHarnessReportPath(rootDir, context.positionals[1] ?? context.flags.report);
+            const report = readHarnessReport(reportPath);
+            const validation = validateHarnessReport(report, rootDir);
+            if (!context.dryRun) {
+                writeHarnessReportArtifacts({
+                    rootDir,
+                    report,
+                    validation,
+                    markdown: context.flags.summary === 'true',
+                });
+            }
+            context.output.writeData(validation, { status: validation.status === 'pass' ? 'success' : 'error' });
+            return { exitCode: validation.status === 'pass' ? 0 : 1 };
+        }
+        case 'approve': {
+            const reportPath = resolveHarnessReportPath(rootDir, context.positionals[1] ?? context.flags.report);
+            const approval = await approveHarnessReport({
+                rootDir,
+                reportPath,
+                yes: context.yes,
+                interactive: context.interactive,
+            });
+            context.output.writeData({
+                report: {
+                    reportId: approval.report.reportId,
+                    reportHash: hashHarnessReport(approval.report),
+                    path: normalizePath(relative(rootDir, reportPath)) || '.moda/harness-report.json',
+                },
+                validation: approval.validation,
+                approval: approval.approval,
+            });
+            return { exitCode: 0 };
+        }
+        case 'agents': {
+            const graph = loadOrScanHarness(rootDir, tenant);
+            context.output.writeData({
+                summary: summarizeHarness(graph),
+                agentFamilies: graph.agentFamilies,
+                runtimeAgents: graph.runtimeAgents,
+                unknowns: graph.unknowns,
+            });
+            return { exitCode: 0 };
+        }
+        case 'graph': {
+            const graph = loadOrScanHarness(rootDir, tenant);
+            context.output.writeData(graph);
+            return { exitCode: 0 };
+        }
+        case 'explain': {
+            const graph = loadOrScanHarness(rootDir, tenant);
+            if (selectedAgentId) {
+                const agent = graph.runtimeAgents.find((candidate) => candidate.id === selectedAgentId);
+                if (!agent) {
+                    throw new CliInputError(`Runtime agent '${selectedAgentId}' was not found in the harness graph.`, 'Run `moda harness agents` to inspect detected runtime agents.');
+                }
+                context.output.writeData(explainAgent(graph, agent));
+                return { exitCode: 0 };
+            }
+            context.output.writeData({
+                summary: summarizeHarness(graph),
+                markdown: renderHarnessMarkdown(graph),
+                unknowns: graph.unknowns,
+            });
+            return { exitCode: 0 };
+        }
+        case 'write-summary': {
+            const graph = loadOrScanHarness(rootDir, tenant);
+            const summaryPath = writeHarnessSummary(graph, rootDir);
+            context.output.writeData({
+                summary: summarizeHarness(graph),
+                written: [summaryPath],
+            });
+            return { exitCode: 0 };
+        }
+        case 'status': {
+            const manifestPath = join(rootDir, HARNESS_PATH);
+            const graph = existsSync(manifestPath)
+                ? readHarnessGraph(manifestPath)
+                : scanHarness({
+                    rootDir,
+                    tenantId: tenant?.tenantId,
+                    tenantSource: tenant?.source,
+                });
+            const currentGraphHash = hashStableJson(graphForSync(graph));
+            const syncState = readHarnessSyncState(rootDir);
+            context.output.writeData({
+                manifest: HARNESS_PATH,
+                exists: existsSync(manifestPath),
+                summary: summarizeHarness(graph),
+                graphHash: currentGraphHash,
+                sync: syncState
+                    ? {
+                        statePath: SYNC_STATE_PATH,
+                        lastSyncedAt: syncState.updatedAt,
+                        profile: syncState.profile,
+                        tenantId: syncState.tenantId,
+                        harnessId: syncState.harnessId,
+                        remoteHarnessId: syncState.remote.harnessId,
+                        remoteVersionId: syncState.remote.versionId,
+                        remoteGraphHash: syncState.remote.graphHash,
+                        localGraphHash: syncState.localGraphHash,
+                        stale: syncState.localGraphHash !== currentGraphHash,
+                    }
+                    : {
+                        statePath: SYNC_STATE_PATH,
+                        lastSyncedAt: null,
+                        stale: true,
+                    },
+                stale: syncState ? syncState.localGraphHash !== currentGraphHash : true,
+            });
+            return { exitCode: 0 };
+        }
+        default:
+            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) {
+    if (context.outputMode === 'human') {
+        if (!context.quiet)
+            console.log(renderHarnessAnalyzeHumanResult(payload));
+        return;
+    }
+    const validationPassed = payload.validation.status === 'pass';
+    context.output.writeData(payload, {
+        status: validationPassed ? 'success' : 'error',
+        summary: validationPassed
+            ? 'Moda Analyst produced and validated a cited harness report.'
+            : 'Moda Analyst produced a harness report, but validation failed.',
+        findings: [
+            {
+                id: 'harness_analyze:validation',
+                title: 'Harness report validation',
+                status: payload.validation.status,
+                severity: validationPassed ? 'info' : 'error',
+                description: validationPassed
+                    ? 'The report is ready for human review and approval.'
+                    : 'Review validation errors before syncing the harness graph.',
+            },
+        ],
+        artifacts: payload.written.map((file) => ({
+            kind: file.includes('harness-report') || file.includes('HARNESS_REPORT')
+                ? 'harness_report_artifact'
+                : 'harness_graph_artifact',
+            path: file,
+            description: 'Written by Moda Analyst.',
+        })),
+        nextCommands: validationPassed
+            ? [
+                {
+                    command: 'moda harness approve --yes',
+                    purpose: 'Approve the cited report after human review.',
+                    mutability: 'write',
+                    requires_approval: true,
+                },
+                {
+                    command: 'moda harness sync --from-report .moda/harness-report.json --summary',
+                    purpose: 'Sync the approved harness graph to Moda Cloud.',
+                    mutability: 'sync',
+                    requires_approval: true,
+                },
+            ]
+            : [
+                {
+                    command: 'moda harness validate-report --summary',
+                    purpose: 'Re-run citation and schema validation after fixing the report.',
+                    mutability: 'read',
+                    requires_approval: false,
+                },
+            ],
+    });
+}
+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.');
+    }
+    const prompt = renderExternalHarnessAnalystPrompt({
+        adapter: options.adapter,
+        rootDir: options.rootDir,
+        tenantId: options.tenant?.tenantId,
+    });
+    const invocation = resolveExternalHarnessAnalystInvocation({
+        adapter: options.adapter,
+        flags: options.context.flags,
+        prompt,
+        rootDir: options.rootDir,
+        stream: options.context.outputMode === 'human',
+    });
+    options.context.output.writeEvent({
+        event: 'progress',
+        phase: 'analyst_launch',
+        message: `Launching ${analystDisplayName(options.adapter)} in read-only analyst mode.`,
+        elapsed_ms: Date.now() - options.context.startedAt,
+    });
+    const inheritedOutput = options.context.outputMode === 'human';
+    const analystTui = shouldUseAnalystTui(options.context.flags, options.context.outputMode) && invocation.streamEvents && !options.context.quiet
+        ? new AnalystTui({
+            adapterName: analystDisplayName(options.adapter),
+            command: invocation.command,
+            root: options.rootDir,
+            reportPath: HARNESS_REPORT_PATH,
+            startedAt: options.context.startedAt,
+        })
+        : undefined;
+    if (analystTui) {
+        analystTui.start();
+    }
+    else {
+        writeHumanBlock(options.context, renderHarnessAnalystLaunch({
+            adapterName: analystDisplayName(options.adapter),
+            command: invocation.command,
+            root: options.rootDir,
+            reportPath: HARNESS_REPORT_PATH,
+        }));
+    }
+    const timeoutMs = numericEnv('MODA_HARNESS_ANALYST_TIMEOUT_MS', 20 * 60 * 1000);
+    try {
+        const result = await runExternalAnalystWithRetries(invocation, {
+            cwd: options.rootDir,
+            env: buildExternalAnalystEnv(options.context.env),
+            inheritedOutput,
+            timeoutMs,
+            maxBuffer: 20 * 1024 * 1024,
+            progress: (inheritedOutput && !options.context.quiet) || options.context.outputMode === 'agent-stream',
+            progressToStderr: inheritedOutput && !options.context.quiet && !analystTui,
+            streamEvents: invocation.streamEvents,
+            adapter: invocation.adapter,
+            tui: analystTui,
+            maxAttempts: externalAnalystMaxAttempts(options.adapter),
+            backoffMs: numericEnvAllowZero('MODA_HARNESS_ANALYST_RETRY_BACKOFF_MS', 6_000),
+            onProgress: (message, phase = 'analyst') => {
+                options.context.output.writeEvent({
+                    event: 'progress',
+                    phase,
+                    message,
+                    elapsed_ms: Date.now() - options.context.startedAt,
+                });
+            },
+        });
+        if (result.error) {
+            throw new CliInputError(`Harness analyst ${options.adapter} failed to run: ${result.error.message}`, 'Check that the selected coding agent CLI is installed and authenticated, or run `moda harness analyze --analyst=local-scan` for the deterministic fallback.');
+        }
+        if (result.timedOut) {
+            throw new CliInputError(`Harness analyst ${options.adapter} timed out after ${Math.round(timeoutMs / 1000)}s.`, 'Run from a narrower agent project root, pass --path=<agent-dir>, or retry after the analyst CLI is responsive.');
+        }
+        if (result.maxBufferExceeded) {
+            throw new CliInputError(`Harness analyst ${options.adapter} produced more than 20MiB of output.`, 'Retry with a narrower --path or ask the analyst to write the report directly instead of printing large logs.');
+        }
+        if (result.status !== 0) {
+            const output = inheritedOutput
+                ? ''
+                : truncateText(`${result.stdout}\n${result.stderr}`, 1200);
+            throw new CliInputError(`Harness analyst ${options.adapter} exited with status ${result.status ?? 'unknown'}.`, output || 'Rerun with the selected coding agent CLI fixed, or choose another analyst with `--analyst=claude|codex|cursor`.');
+        }
+        const report = readExternalAnalystReport(options.rootDir, result, options.adapter);
+        analystTui?.setSummary({
+            runtimeAgentCount: report.graph.runtimeAgents.length,
+            agentFamilyCount: report.graph.agentFamilies.length,
+            artifactCount: report.graph.artifacts.length,
+            modelProviderCount: report.graph.modelProviders.length,
+            unknownCount: report.graph.unknowns.length,
+            claimCount: report.claims.length,
+            citationCount: report.citations.length,
+            relationshipCount: report.graph.relationships.length,
+        });
+        options.context.output.writeEvent({
+            event: 'progress',
+            phase: 'validation',
+            message: `Validating ${HARNESS_REPORT_PATH}.`,
+            elapsed_ms: Date.now() - options.context.startedAt,
+        });
+        analystTui?.setValidation('running');
+        const validation = validateHarnessReport(report, options.rootDir);
+        analystTui?.setValidation(validation.status === 'pass' ? 'pass' : 'fail');
+        if (!analystTui)
+            writeHumanProgress(options.context, `Moda Analyst: validation ${validation.status}.`);
+        const written = [
+            ...writeHarnessReportArtifacts({
+                rootDir: options.rootDir,
+                report,
+                validation,
+                markdown: options.context.flags.summary === 'true' || options.context.outputMode === 'human',
+            }),
+        ];
+        if (validation.status === 'pass') {
+            written.push(...writeHarnessArtifacts(report.graph, options.rootDir, {
+                summary: options.context.flags.summary === 'true',
+            }));
+        }
+        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,
+            });
+        }
+        analystTui?.complete(validation.status === 'pass' ? 'pass' : 'fail');
+        analystTui?.stop();
+        writeHarnessAnalyzeResult(options.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 };
+    }
+    catch (error) {
+        analystTui?.complete('fail');
+        analystTui?.stop();
+        throw error;
+    }
+}
+function buildExternalAnalystEnv(env) {
+    const next = {
+        ...env,
+        MODA_CLI_TELEMETRY: '0',
+        DO_NOT_TRACK: '1',
+    };
+    const analystHome = env.MODA_HARNESS_ANALYST_HOME;
+    if (analystHome && analystHome !== 'true') {
+        next.HOME = analystHome === '~' ? homedir() : analystHome;
+        next.USERPROFILE = next.HOME;
+    }
+    return next;
+}
+function readExternalAnalystReport(rootDir, result, adapter) {
+    const reportPath = resolve(rootDir, HARNESS_REPORT_PATH);
+    if (existsSync(reportPath))
+        return repairExternalAnalystReport(readHarnessReport(reportPath), rootDir);
+    const output = [
+        result.stdout,
+        result.stderr,
+        extractAgentTextFromOutput(result.stdout),
+        extractAgentTextFromOutput(result.stderr),
+    ].filter(Boolean).join('\n');
+    const parsed = extractHarnessReportFromText(output, rootDir);
+    if (parsed)
+        return parsed;
+    throw new CliInputError(`Harness analyst ${adapter} did not return a harness report.`, [
+        `Expected ${HARNESS_REPORT_PATH} or final JSON between ${REPORT_JSON_BEGIN} and ${REPORT_JSON_END}.`,
+        'Retry with the selected coding agent CLI fixed, choose another analyst, or run `moda harness analyze --analyst=local-scan --summary` for deterministic fallback.',
+    ].join('\n'));
+}
+function extractHarnessReportFromText(output, rootDir) {
+    for (const candidate of reportJsonCandidates(output)) {
+        const parsed = parseHarnessReportCandidate(candidate);
+        if (parsed)
+            return repairExternalAnalystReport(parsed, rootDir);
+    }
+    return undefined;
+}
+function reportJsonCandidates(output) {
+    const candidates = [];
+    const markerPattern = new RegExp(`${escapeRegExp(REPORT_JSON_BEGIN)}\\s*([\\s\\S]*?)\\s*${escapeRegExp(REPORT_JSON_END)}`, 'g');
+    for (const match of output.matchAll(markerPattern)) {
+        if (match[1])
+            candidates.push(match[1]);
+    }
+    const fencePattern = /```(?:json)?\s*([\s\S]*?)```/gi;
+    for (const match of output.matchAll(fencePattern)) {
+        if (match[1]?.includes('harness_report.v0.1'))
+            candidates.push(match[1]);
+    }
+    const firstBrace = output.indexOf('{');
+    const lastBrace = output.lastIndexOf('}');
+    if (firstBrace !== -1 && lastBrace > firstBrace) {
+        candidates.push(output.slice(firstBrace, lastBrace + 1));
+    }
+    return candidates;
+}
+function parseHarnessReportCandidate(candidate) {
+    try {
+        const parsed = JSON.parse(candidate.trim());
+        if (isRecord(parsed) && parsed.schemaVersion === 'harness_report.v0.1') {
+            return parsed;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function repairExternalAnalystReport(report, rootDir) {
+    const normalized = normalizeHarnessReport(report);
+    repairCitationLines(normalized, rootDir);
+    repairReportSummaryCounts(normalized);
+    return normalized;
+}
+function repairReportSummaryCounts(report) {
+    const graph = report.graph;
+    report.summary = {
+        ...report.summary,
+        runtimeAgentCount: graph.runtimeAgents.length,
+        agentFamilyCount: graph.agentFamilies.length,
+        artifactCount: graph.artifacts.length,
+        sharedArtifactCount: graph.artifacts.filter((artifact) => artifact.scope === 'shared').length,
+        channelAdapterCount: graph.channelAdapters.length,
+        identityNamespaceCount: graph.identityNamespaces.length,
+        environmentCount: graph.environments.length,
+        agentFrameworkCount: graph.agentFrameworks.length,
+        modelProviderCount: graph.modelProviders.length,
+        deploymentCount: graph.deployments.length,
+        relationshipCount: graph.relationships.length,
+        unknownCount: graph.unknowns.length,
+    };
+}
+function repairCitationLines(report, rootDir) {
+    for (const citation of report.citations) {
+        if ((citation.type !== 'file' && citation.type !== 'generated_doc') || !citation.path || !citation.excerpt)
+            continue;
+        const excerpt = citation.excerpt;
+        const candidatePath = resolve(rootDir, citation.path);
+        if (!existsSync(candidatePath))
+            continue;
+        let text;
+        try {
+            text = readFileSync(candidatePath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const lines = text.split(/\r?\n/);
+        const currentLine = typeof citation.line === 'number' ? lines[citation.line - 1] : undefined;
+        if (currentLine && citationLineMatches(currentLine, excerpt))
+            continue;
+        const matchedIndex = lines.findIndex((line) => citationLineMatches(line, excerpt));
+        if (matchedIndex >= 0)
+            citation.line = matchedIndex + 1;
+    }
+}
+function citationLineMatches(line, excerpt) {
+    return normalizeComparableLine(line).includes(normalizeComparableLine(excerpt));
+}
+function normalizeComparableLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function extractAgentTextFromOutput(output) {
+    const lines = [];
+    for (const line of output.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const event = JSON.parse(trimmed);
+            const text = extractTextFromAgentEvent(event);
+            if (text)
+                lines.push(text);
+        }
+        catch {
+            lines.push(trimmed);
+        }
+    }
+    return lines.join('\n');
+}
+function extractTextFromAgentEvent(event) {
+    if (!isRecord(event))
+        return undefined;
+    const directText = stringValue(event.text) ??
+        stringValue(event.message) ??
+        stringValue(event.delta) ??
+        stringValue(event.result);
+    if (directText)
+        return directText;
+    const message = isRecord(event.message) ? event.message : undefined;
+    const messageText = message
+        ? stringValue(message.text) ?? stringValue(message.content)
+        : undefined;
+    if (messageText)
+        return messageText;
+    const content = Array.isArray(message?.content)
+        ? message.content
+        : Array.isArray(event.content)
+            ? event.content
+            : [];
+    const textParts = content
+        .map((part) => {
+        if (!isRecord(part))
+            return undefined;
+        return stringValue(part.text) ?? stringValue(part.content);
+    })
+        .filter((part) => Boolean(part));
+    return textParts.length > 0 ? textParts.join('\n') : undefined;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function runExternalAnalystProcess(invocation, options) {
+    return new Promise((resolveProcess) => {
+        const child = spawn(invocation.command, invocation.args, {
+            cwd: options.cwd,
+            env: options.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        const startedAt = Date.now();
+        let lastOutputAt = startedAt;
+        let sawOutput = false;
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+        let maxBufferExceeded = false;
+        let settled = false;
+        let eventLineBuffer = '';
+        const progressMs = numericEnv('MODA_HARNESS_ANALYST_PROGRESS_MS', 8_000);
+        const progressTimer = options.progress
+            ? setInterval(() => {
+                const elapsed = Math.max(1, Math.round((Date.now() - startedAt) / 1000));
+                const quietFor = Math.max(0, Math.round((Date.now() - lastOutputAt) / 1000));
+                const status = sawOutput
+                    ? `${quietFor}s since analyst output`
+                    : 'waiting for first analyst output';
+                const message = `Moda Analyst: still investigating (${elapsed}s elapsed, ${status})...`;
+                options.onProgress?.(message, 'analyst_wait');
+                options.tui?.heartbeat({ elapsedSeconds: elapsed, quietForSeconds: quietFor, sawOutput });
+                if (options.progressToStderr) {
+                    process.stderr.write(`${renderHarnessProgress(message)}\n`);
+                }
+            }, progressMs)
+            : undefined;
+        const timeoutTimer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            setTimeout(() => {
+                if (!settled)
+                    child.kill('SIGKILL');
+            }, 5_000).unref();
+        }, options.timeoutMs);
+        const flushEventLines = () => {
+            if (!eventLineBuffer)
+                return;
+            recordExternalAgentEventLine(eventLineBuffer, options);
+            eventLineBuffer = '';
+        };
+        const appendOutput = (stream, chunk) => {
+            sawOutput = true;
+            lastOutputAt = Date.now();
+            const text = chunk.toString('utf8');
+            if (stream === 'stdout')
+                stdout += text;
+            else
+                stderr += text;
+            if (options.inheritedOutput) {
+                if (options.tui && stream === 'stderr') {
+                    recordExternalAgentTextChunk(text, options.tui);
+                }
+                else if (options.streamEvents && stream === 'stdout') {
+                    eventLineBuffer += text;
+                    const lines = eventLineBuffer.split(/\r?\n/);
+                    eventLineBuffer = lines.pop() ?? '';
+                    for (const line of lines) {
+                        recordExternalAgentEventLine(line, options);
+                    }
+                }
+                else {
+                    process.stderr.write(chunk);
+                }
+            }
+            if (stdout.length + stderr.length > options.maxBuffer && !maxBufferExceeded) {
+                maxBufferExceeded = true;
+                child.kill('SIGTERM');
+            }
+        };
+        child.stdout.on('data', (chunk) => appendOutput('stdout', chunk));
+        child.stderr.on('data', (chunk) => appendOutput('stderr', chunk));
+        child.on('error', (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutTimer);
+            if (progressTimer)
+                clearInterval(progressTimer);
+            flushEventLines();
+            resolveProcess({
+                status: null,
+                signal: null,
+                stdout,
+                stderr,
+                error,
+                timedOut,
+                maxBufferExceeded,
+            });
+        });
+        child.on('close', (status, signal) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeoutTimer);
+            if (progressTimer)
+                clearInterval(progressTimer);
+            flushEventLines();
+            resolveProcess({
+                status,
+                signal,
+                stdout,
+                stderr,
+                timedOut,
+                maxBufferExceeded,
+            });
+        });
+    });
+}
+async function runExternalAnalystWithRetries(invocation, options) {
+    let lastResult;
+    for (let attempt = 1; attempt <= options.maxAttempts; attempt += 1) {
+        if (attempt > 1) {
+            const message = `Moda Analyst: retrying ${analystDisplayName(options.adapter)} after transient provider failure (${attempt}/${options.maxAttempts}).`;
+            options.onProgress?.(message, 'analyst_retry');
+            options.tui?.recordEvent({ kind: 'system', message });
+            if (options.progressToStderr)
+                process.stderr.write(`${renderHarnessProgress(message)}\n`);
+            if (options.backoffMs > 0)
+                await sleep(options.backoffMs);
+        }
+        lastResult = await runExternalAnalystProcess(invocation, options);
+        if (!isRetryableExternalAnalystFailure(lastResult))
+            return lastResult;
+    }
+    return lastResult;
+}
+function isRetryableExternalAnalystFailure(result) {
+    if (result.error || result.timedOut || result.maxBufferExceeded)
+        return false;
+    if (result.status === 0)
+        return false;
+    const output = `${result.stdout}\n${result.stderr}`;
+    return /\b529\b|overloaded|server-side issue|temporar(?:y|ily)|try again|rate limit|too many requests|\b429\b|service unavailable/i.test(output);
+}
+function externalAnalystMaxAttempts(adapter) {
+    const defaultRetries = adapter === 'claude' ? 2 : 1;
+    return 1 + numericEnvAllowZero('MODA_HARNESS_ANALYST_RETRIES', defaultRetries);
+}
+function sleep(ms) {
+    return new Promise((resolveSleep) => setTimeout(resolveSleep, ms));
+}
+function recordExternalAgentTextChunk(text, tui) {
+    for (const line of text.split(/\r?\n/)) {
+        const message = line.trim();
+        if (!message)
+            continue;
+        tui.recordEvent({ kind: 'system', message: truncateText(message, 500) });
+    }
+}
+function recordExternalAgentEventLine(line, options) {
+    const event = parseExternalAgentEventLine(line);
+    if (!event)
+        return;
+    options.tui?.recordEvent(event);
+    if (options.tui)
+        return;
+    const formatted = formatExternalAgentDisplayEvent(event, options.adapter);
+    if (formatted)
+        process.stderr.write(formatted);
+}
+function formatExternalAgentEventLine(line, adapter) {
+    const event = parseExternalAgentEventLine(line);
+    return event ? formatExternalAgentDisplayEvent(event, adapter) : undefined;
+}
+function parseExternalAgentEventLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const event = JSON.parse(trimmed);
+        return parseExternalAgentEvent(event);
+    }
+    catch {
+        return { kind: 'agent_text', message: truncateText(trimmed, 500) };
+    }
+}
+function formatExternalAgentDisplayEvent(event, adapter) {
+    if (event.kind === 'tool')
+        return undefined;
+    return `  ${analystDisplayName(adapter)}: ${event.message}\n`;
+}
+function parseExternalAgentEvent(event) {
+    if (!isRecord(event))
+        return { kind: 'agent_text', message: truncateText(String(event), 500) };
+    const msg = isRecord(event.msg) ? event.msg : undefined;
+    const call = isRecord(event.call) ? event.call : undefined;
+    const type = stringValue(event.type) ?? stringValue(event.event) ?? stringValue(msg?.type);
+    const subtype = stringValue(event.subtype);
+    if (type === 'rate_limit_event')
+        return { kind: 'rate_limit', message: 'rate limit wait' };
+    const toolName = stringValue(event.name) ??
+        stringValue(event.tool_name) ??
+        stringValue(event.toolName) ??
+        stringValue(call?.name);
+    if (toolName && /tool|call|exec|command|bash/i.test(`${type ?? ''} ${subtype ?? ''}`)) {
+        return { kind: 'tool', toolName, message: `tool ${toolName}` };
+    }
+    const directText = stringValue(event.text) ??
+        stringValue(event.message) ??
+        stringValue(event.delta) ??
+        stringValue(event.result);
+    if (directText && !isLowSignalEventType(type)) {
+        return { kind: 'agent_text', message: truncateText(firstMeaningfulLine(directText), 500) };
+    }
+    const message = isRecord(event.message) ? event.message : undefined;
+    const messageText = message
+        ? stringValue(message.text) ?? stringValue(message.content)
+        : undefined;
+    if (messageText && !isLowSignalEventType(type)) {
+        return { kind: 'agent_text', message: truncateText(firstMeaningfulLine(messageText), 500) };
+    }
+    const content = Array.isArray(message?.content)
+        ? message.content
+        : Array.isArray(event.content)
+            ? event.content
+            : [];
+    for (const part of content) {
+        const parsed = parseAgentContentPart(part);
+        if (parsed)
+            return parsed;
+    }
+    const command = stringValue(event.command) ?? stringValue(event.cmd);
+    if (command)
+        return { kind: 'command', message: `command ${truncateText(command, 300)}` };
+    if (type && !isLowSignalEventType(type)) {
+        return { kind: 'system', message: subtype ? `${type}:${subtype}` : type };
+    }
+    return undefined;
+}
+function parseAgentContentPart(part) {
+    if (!isRecord(part))
+        return undefined;
+    const partType = stringValue(part.type);
+    if (partType === 'tool_use' || partType === 'tool_call') {
+        const name = stringValue(part.name) ?? stringValue(part.tool_name);
+        return name ? { kind: 'tool', toolName: name, message: `tool ${name}` } : undefined;
+    }
+    if (partType === 'tool_result' || partType === 'tool_output')
+        return undefined;
+    if (partType === 'text' || partType === 'output_text') {
+        const text = stringValue(part.text) ?? stringValue(part.content);
+        return text ? { kind: 'agent_text', message: truncateText(firstMeaningfulLine(text), 500) } : undefined;
+    }
+    const name = stringValue(part.name) ?? stringValue(part.tool_name);
+    if (name)
+        return { kind: 'tool', toolName: name, message: `tool ${name}` };
+    return undefined;
+}
+function firstMeaningfulLine(value) {
+    return value.split(/\r?\n/).map((line) => line.trim()).find(Boolean) ?? value.trim();
+}
+function isLowSignalEventType(type) {
+    return !type ||
+        type === 'assistant' ||
+        type === 'user' ||
+        type === 'system' ||
+        type === 'session' ||
+        type === 'turn_start' ||
+        type === 'turn_end' ||
+        type === 'tool_use' ||
+        type === 'tool_result' ||
+        type === 'tool_call' ||
+        type === 'tool_output' ||
+        type === 'token_count' ||
+        type === 'usage' ||
+        type.endsWith('_delta');
+}
+function analystDisplayName(adapter) {
+    if (adapter === 'claude')
+        return 'Claude Code';
+    if (adapter === 'cursor')
+        return 'Cursor';
+    return 'Codex';
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function summarizeInvalidAnalystReport(report) {
+    if (!report || typeof report !== 'object')
+        return { status: 'invalid_report' };
+    const reportRecord = report;
+    const graph = reportRecord.graph && typeof reportRecord.graph === 'object'
+        ? reportRecord.graph
+        : {};
+    return {
+        status: 'validation_failed',
+        schemaVersion: typeof graph.schemaVersion === 'string' ? graph.schemaVersion : undefined,
+        harnessId: typeof reportRecord.harnessId === 'string'
+            ? reportRecord.harnessId
+            : typeof graph.harnessId === 'string'
+                ? graph.harnessId
+                : undefined,
+        runtimeAgentCount: countArray(graph.runtimeAgents),
+        agentFamilyCount: countArray(graph.agentFamilies),
+        artifactCount: countArray(graph.artifacts),
+        channelAdapterCount: countArray(graph.channelAdapters),
+        identityNamespaceCount: countArray(graph.identityNamespaces),
+        agentFrameworkCount: countArray(graph.agentFrameworks),
+        modelProviderCount: countArray(graph.modelProviders),
+        deploymentCount: countArray(graph.deployments),
+        unknownCount: countArray(graph.unknowns),
+    };
+}
+function countArray(value) {
+    return Array.isArray(value) ? value.length : undefined;
+}
+async function resolveHarnessAnalystAdapter(context) {
+    const requested = normalizeAnalystAdapter(context.flags.analyst);
+    if (requested !== 'auto')
+        return requested;
+    const available = rankHarnessAnalysts(detectAvailableHarnessAnalysts());
+    if (available.length > 0) {
+        writeHumanBlock(context, renderHarnessAnalystChoice({
+            detected: available.map((item) => `${analystDisplayName(item.adapter)} (${item.command})`),
+        }));
+    }
+    if (available.length === 1) {
+        writeHumanProgress(context, `Using ${analystDisplayName(available[0].adapter)} for read-only harness investigation.`);
+        return available[0].adapter;
+    }
+    if (available.length > 1 && shouldPromptForHarnessAnalyst(context)) {
+        return select({
+            message: 'Choose which coding agent should investigate this harness',
+            choices: available.map((item) => ({
+                name: `${analystDisplayName(item.adapter)} (${item.command})`,
+                value: item.adapter,
+            })),
+        });
+    }
+    if (available.length > 1) {
+        writeHumanProgress(context, `Using ${analystDisplayName(available[0].adapter)} for read-only harness investigation. Pass --analyst=claude|codex|cursor to choose explicitly.`);
+        return available[0].adapter;
+    }
+    throw new CliInputError('No external harness analyst CLI was found.', [
+        'Install/sign into Claude Code, Codex, or Cursor, then rerun `moda harness analyze`.',
+        'Set MODA_HARNESS_ANALYST_COMMAND to an explicit analyst command.',
+        'For deterministic debugging only, run `moda harness analyze --analyst=local-scan`.',
+    ].join('\n'));
+}
+function detectAvailableHarnessAnalysts() {
+    return EXTERNAL_ANALYST_ADAPTERS
+        .map((adapter) => ({ adapter, command: resolveAnalystCommand(adapter) }))
+        .filter((item) => Boolean(item.command));
+}
+function rankHarnessAnalysts(analysts) {
+    return [...analysts].sort((a, b) => analystQualityScore(b.adapter) - analystQualityScore(a.adapter));
+}
+function analystQualityScore(adapter) {
+    if (adapter === 'claude')
+        return 3;
+    if (adapter === 'codex')
+        return 2;
+    return 1;
+}
+function shouldPromptForHarnessAnalyst(context) {
+    return context.outputMode === 'human' &&
+        !context.yes &&
+        process.stdin.isTTY === true &&
+        !context.flags['analyst-command'] &&
+        !process.env.MODA_HARNESS_ANALYST_COMMAND;
+}
+function normalizeAnalystAdapter(raw) {
+    const value = (raw && raw !== 'true' ? raw : 'auto').trim().toLowerCase();
+    if (value === 'auto')
+        return 'auto';
+    if (value === 'claude' || value === 'claude-code' || value === 'claude_code')
+        return 'claude';
+    if (value === 'codex' || value === 'codex-cli' || value === 'codex_cli')
+        return 'codex';
+    if (value === 'cursor' || value === 'cursor-cli' || value === 'cursor_cli')
+        return 'cursor';
+    if (value === 'local-scan' || value === 'local' || value === 'scripted' || value === 'moda')
+        return 'local-scan';
+    throw new CliInputError(`Unknown harness analyst '${raw}'.`, 'Use `--analyst=claude|codex|cursor|local-scan`.');
+}
+function resolveExternalHarnessAnalystInvocation(options) {
+    const override = options.flags['analyst-command'] || process.env.MODA_HARNESS_ANALYST_COMMAND;
+    if (override) {
+        const [command, ...args] = splitCommandLine(override);
+        if (!command) {
+            throw new CliInputError('Analyst command override is empty.');
+        }
+        return { adapter: options.adapter, command, args: [...args, options.prompt], streamEvents: false };
+    }
+    const command = resolveAnalystCommand(options.adapter);
+    if (!command) {
+        throw new CliInputError(`${titleFromId(options.adapter)} analyst CLI was not found.`, `Install/sign into ${titleFromId(options.adapter)}, set MODA_HARNESS_ANALYST_COMMAND, or choose another analyst with --analyst=claude|codex|cursor.`);
+    }
+    if (options.adapter === 'claude') {
+        const extraArgs = externalAnalystExtraArgs(options.adapter);
+        return {
+            adapter: options.adapter,
+            command,
+            args: [
+                '--print',
+                ...extraArgs,
+                '--permission-mode',
+                'plan',
+                '--allowedTools',
+                'Read,Grep,Glob,Bash(pwd),Bash(ls *),Bash(find *),Bash(rg *),Bash(grep *),Bash(cat *),Bash(git status *),Bash(git ls-files *),Bash(git grep *)',
+                ...(options.stream ? ['--verbose'] : []),
+                '--output-format',
+                options.stream ? 'stream-json' : 'text',
+                '--no-session-persistence',
+                options.prompt,
+            ],
+            streamEvents: options.stream,
+        };
+    }
+    if (options.adapter === 'codex') {
+        return {
+            adapter: options.adapter,
+            command,
+            args: [
+                'exec',
+                '--skip-git-repo-check',
+                '--sandbox',
+                'read-only',
+                ...(options.stream ? ['--json'] : []),
+                '-C',
+                options.rootDir,
+                options.prompt,
+            ],
+            streamEvents: options.stream,
+        };
+    }
+    return {
+        adapter: options.adapter,
+        command,
+        args: cursorSubcommandArgs(command, [
+            '--print',
+            '--trust',
+            '--mode',
+            'plan',
+            '--sandbox',
+            'enabled',
+            '--workspace',
+            options.rootDir,
+            '--output-format',
+            options.stream ? 'stream-json' : 'text',
+            options.prompt,
+        ]),
+        streamEvents: options.stream,
+    };
+}
+function externalAnalystExtraArgs(adapter) {
+    return splitCommandLine(process.env[`MODA_HARNESS_ANALYST_${adapter.toUpperCase()}_ARGS`] ?? '');
+}
+function renderExternalHarnessAnalystPrompt(options) {
+    return [
+        'You are Moda Analyst, investigating an agent harness for Moda CLI onboarding.',
+        '',
+        'Do real repository investigation. Do not call `moda harness scan`, `moda harness analyze`, or rely on deterministic Moda scanner output.',
+        'Only inspect the Repository root named below and files/directories under it. Do not inspect parent directories, sibling projects, the Moda CLI implementation, or this monorepo unless the Repository root itself is that directory.',
+        'Inspect package manifests, source files, prompt files, tool definitions, skills/rules, evals, deployment config, and README/AGENTS docs as needed.',
+        'Do not read secret-looking files such as .env files, private keys, credential files, or token stores.',
+        'You are running as a read-only analyst. Do not edit source files, configuration files, git state, dependency files, or project metadata.',
+        'Prefer printing the final report JSON for Moda CLI to validate and write. If your runtime unexpectedly allows file writes, only `.moda/harness-report.json` is permitted.',
+        '',
+        'Your task:',
+        renderExternalAnalystProtocol(),
+        '1. Identify the actual runtime agent harnesses, agent families, prompts, tools, channel adapters, identity mappings, evals, model providers, frameworks, deployments, and open questions.',
+        '2. Cite every claim with local file paths, exact line numbers, and excerpts. File citations without line numbers are invalid for agent-authored reports.',
+        `3. After completing investigation, print the report JSON between ${REPORT_JSON_BEGIN} and ${REPORT_JSON_END}. Moda CLI will validate it and write the local artifacts.`,
+        'Your final response must contain the sentinel-wrapped JSON report. Do not end with commentary about being read-only, do not summarize without JSON, and do not omit the sentinel markers.',
+        'If the repository is too large to fully enumerate, stop broad exploration and produce the best conservative cited report with unknowns instead of continuing indefinitely.',
+        '',
+        'Final output format:',
+        REPORT_JSON_BEGIN,
+        '{',
+        '  "...": "valid harness_report.v0.1 JSON"',
+        '}',
+        REPORT_JSON_END,
+        '',
+        'The report must be JSON with this top-level contract:',
+        '- schemaVersion: "harness_report.v0.1"',
+        '- reportId, harnessId, createdAt',
+        `- analyst: { "id": "moda-${options.adapter}-analyst", "adapter": "${options.adapter}", "mode": "agent", "version": "cli" }`,
+        '- repo: { root: ".", name, packageManagers, languages }',
+        '- source: { graphSchemaVersion: "harness.v0.1", graphHash: "", readPlan, deterministicInventory: false }',
+        '- summary: numeric fields named runtimeAgentCount, agentFamilyCount, artifactCount, sharedArtifactCount, channelAdapterCount, identityNamespaceCount, environmentCount, agentFrameworkCount, modelProviderCount, deploymentCount, relationshipCount, unknownCount',
+        '- graph: an exact sanitized harness.v0.1 graph with arrays for agentFamilies, runtimeAgents, developerAgentAdapters, channelAdapters, artifacts, identityNamespaces, environments, agentFrameworks, modelProviders, deployments, relationships, unknowns',
+        '- claims: cited claims about graph items. Each claim must include kind, subjectId, title, summary, confidence, inference, and citationIds; kind should be one of runtime_agent, agent_family, developer_agent_adapter, artifact, channel_adapter, identity_namespace, environment, agent_framework, model_provider, deployment, relationship, unknown. subjectId should be the id of the runtime agent, agent family, developer adapter, artifact, provider, adapter, deployment, relationship, or unknown being claimed.',
+        '- citations: evidence records with id, type, reason, and excerpt. For type:"file" or type:"generated_doc", include path, line, reason, and excerpt matching that exact line. You may also use type:"command_output" or type:"production_evidence" with excerpt when evidence came from a command or production source.',
+        `- syncPlan: { command: "moda harness sync --from-report ${HARNESS_REPORT_PATH}", dryRunCommand: "moda harness sync --from-report ${HARNESS_REPORT_PATH} --dry-run", uploads: string[], privacy: string[] }`,
+        '- unknowns: report-level open questions with id, question, and citationIds',
+        '',
+        'Use exact field names and numeric confidence values from 0 to 1. Do not write string confidence values like "high". Do not use confidence >= 0.90 unless the claim is direct evidence from the cited line(s).',
+        'Each graph item with evidence must use evidence: [{ path, reason }], not citationIds/citations.',
+        'Runtime agents must include id, name, kind:"runtime_agent", root, entrypointIds, channelAdapterIds, artifactIds, identityNamespaceIds, deploymentIds, frameworkIds, modelProviderIds, confidence, evidence.',
+        'Artifacts must include id, type, name, scope, usedByAgentIds, confidence, evidence, and optional sourcePath/contentHash/ownedByAgentId.',
+        'Agent families must include id, name, runtimeAgentIds, sharedArtifactIds, confidence, evidence.',
+        'Frameworks/providers must include packageNames and runtimeAgentIds arrays; providers also include envVars and modelHints arrays.',
+        'Unknowns in graph must include id, question, candidateIds, evidence. Report-level unknowns must include id, question, citationIds.',
+        'Do not make every claim about the repo or harness id. Claims should name the specific graph item they support.',
+        '',
+        'Set source.graphHash to an empty string if you cannot compute Moda stable graph hashing; Moda CLI will still validate citations and schema.',
+        options.tenantId ? `Tenant ID to include in graph.tenant: ${options.tenantId}` : 'No tenant ID was provided for this analysis.',
+        `Repository root: ${options.rootDir}`,
+        renderAnalystPreflightSection(options.rootDir),
+        '',
+        'Be conservative. If something is unclear, put it in unknowns instead of inventing an agent.',
+    ].filter(Boolean).join('\n');
+}
+function renderExternalAnalystProtocol() {
+    const protocol = process.env.MODA_HARNESS_ANALYST_PROTOCOL?.trim().toLowerCase();
+    if (protocol === 'classic' || protocol === 'none' || protocol === '0')
+        return '';
+    return [
+        'Focused investigation protocol:',
+        '- First build a quick repo map with read-only commands such as pwd, git ls-files, rg, and targeted manifest/doc reads.',
+        '- Prioritize runtime entrypoints, prompt/tool definitions, framework/provider calls, channel adapters, evals, and deploy config over exhaustive file enumeration.',
+        '- If the repository is a framework, SDK, or examples collection, do not enumerate every example as a production runtime agent. Model representative harnesses, reusable frameworks, and unknowns conservatively with citations.',
+        '- For every claimed runtime agent, read and cite at least one concrete entrypoint or orchestration line. Add prompt/tool/config citations when available.',
+        '- Stop exploring once the cited graph is sufficiently supported. Use unknowns for unresolved questions instead of continuing broad exploration.',
+        '- Prefer a compact report: target 8-16 high-signal claims and 12-40 citations unless the repo clearly needs more.',
+    ].join('\n');
+}
+function renderAnalystPreflightSection(rootDir) {
+    if (process.env.MODA_HARNESS_ANALYST_PREFLIGHT !== '1')
+        return '';
+    const paths = listAnalystPreflightPaths(rootDir);
+    if (paths.length === 0)
+        return '';
+    const groups = {
+        manifests: paths.filter((path) => isManifestLikePath(path)).slice(0, 60),
+        docs: paths.filter((path) => isDocLikePath(path)).slice(0, 40),
+        source: paths.filter((path) => isAgentNavigationPath(path)).slice(0, 160),
+        deploy: paths.filter((path) => isPreflightDeployLikePath(path)).slice(0, 50),
+        evals: paths.filter((path) => isPreflightEvalLikePath(path)).slice(0, 50),
+    };
+    const lines = [
+        '',
+        'Navigation aid (not evidence):',
+        'Moda generated this path-only map to help you navigate faster. Do not cite it and do not trust it for claims. Read the real files and cite exact lines before asserting anything.',
+        ...renderPreflightGroup('Manifests/config', groups.manifests),
+        ...renderPreflightGroup('Docs/rules', groups.docs),
+        ...renderPreflightGroup('Likely source/prompt/tool paths', groups.source),
+        ...renderPreflightGroup('Deploy/CI', groups.deploy),
+        ...renderPreflightGroup('Evals/tests', groups.evals),
+    ];
+    return lines.join('\n');
+}
+function renderPreflightGroup(label, paths) {
+    if (paths.length === 0)
+        return [];
+    return [`${label}:`, ...paths.map((path) => `- ${path}`)];
+}
+function listAnalystPreflightPaths(rootDir) {
+    const gitPaths = readGitTrackedPaths(rootDir);
+    const paths = gitPaths.length > 0 ? gitPaths : readDirectoryPreflightPaths(rootDir);
+    return [...new Set(paths.map(normalizePath))]
+        .filter((path) => path && !shouldSkipPreflightPath(path))
+        .sort();
+}
+function readGitTrackedPaths(rootDir) {
+    try {
+        return execFileSync('git', ['ls-files', '-co', '--exclude-standard'], {
+            cwd: rootDir,
+            encoding: 'utf8',
+            maxBuffer: 4 * 1024 * 1024,
+        }).split(/\r?\n/).filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
+function readDirectoryPreflightPaths(rootDir) {
+    const paths = [];
+    const stack = ['.'];
+    while (stack.length > 0 && paths.length < 2_000) {
+        const current = stack.pop() ?? '.';
+        const absolute = current === '.' ? rootDir : join(rootDir, current);
+        let entries;
+        try {
+            entries = readdirSync(absolute);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const child = current === '.' ? entry : `${current}/${entry}`;
+            if (shouldSkipPreflightPath(child))
+                continue;
+            const childAbsolute = join(rootDir, child);
+            let stat;
+            try {
+                stat = lstatSync(childAbsolute);
+            }
+            catch {
+                continue;
+            }
+            if (stat.isSymbolicLink())
+                continue;
+            if (stat.isDirectory()) {
+                stack.push(child);
+            }
+            else {
+                paths.push(child);
+            }
+        }
+    }
+    return paths;
+}
+function shouldSkipPreflightPath(path) {
+    const normalized = normalizePath(path);
+    if (!normalized || normalized.startsWith('.moda/'))
+        return true;
+    const parts = normalized.split('/');
+    if (parts.some((part) => SKIPPED_DIRS.has(part)))
+        return true;
+    return isSecretishPath(normalized);
+}
+function isManifestLikePath(path) {
+    const name = basename(path).toLowerCase();
+    return /^(package\.json|pyproject\.toml|requirements.*\.txt|uv\.lock|poetry\.lock|pnpm-lock\.yaml|bun\.lockb?|yarn\.lock|cargo\.toml|go\.mod|deno\.json|turbo\.json|langgraph\.json|agents\.json|config\.(ts|js|json|yaml|yml|toml))$/.test(name);
+}
+function isDocLikePath(path) {
+    const lower = path.toLowerCase();
+    return /(^|\/)(readme|agents|claude|cursor|codex|rules|skills?)(\.[\w-]+)?$/.test(lower) ||
+        lower.includes('/skills/') ||
+        lower.includes('/rules/');
+}
+function isAgentNavigationPath(path) {
+    const lower = path.toLowerCase();
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py|go|rs|cs|java|kt|rb|php|md|yaml|yml|toml|json)$/.test(lower) &&
+        /(agent|assistant|harness|prompt|tool|workflow|graph|model|provider|llm|chat|completion|planner|research|memory|eval|guardrail|router|orchestr|crew|swarm|bot)/.test(lower);
+}
+function isPreflightDeployLikePath(path) {
+    const lower = path.toLowerCase();
+    return lower.startsWith('.github/workflows/') ||
+        lower.includes('/deploy') ||
+        lower.includes('/docker') ||
+        /(dockerfile|compose\.ya?ml|vercel\.json|netlify\.toml|wrangler\.toml|modal\.py|fly\.toml|render\.ya?ml)$/.test(lower);
+}
+function isPreflightEvalLikePath(path) {
+    const lower = path.toLowerCase();
+    return /(^|\/)(test|tests|eval|evals|bench|benchmarks|fixtures)(\/|$)/.test(lower) ||
+        lower.includes('eval') ||
+        lower.includes('benchmark');
+}
+function resolveAnalystCommand(adapter) {
+    const envSpecific = process.env[`MODA_HARNESS_ANALYST_${adapter.toUpperCase()}_COMMAND`];
+    if (envSpecific)
+        return splitCommandLine(envSpecific)[0];
+    if (adapter === 'claude')
+        return findOnPath('claude');
+    if (adapter === 'codex')
+        return findOnPath('codex') || findOnPath('/Applications/Codex.app/Contents/Resources/codex');
+    return findOnPath('cursor-agent') ||
+        findOnPath('cursor-cli') ||
+        findOnPath('cursor') ||
+        findOnPath('/Applications/Cursor.app/Contents/Resources/app/bin/cursor');
+}
+function cursorSubcommandArgs(command, args) {
+    const name = basename(command);
+    return name === 'cursor' || name === 'cursor-cli' ? ['agent', ...args] : args;
+}
+function findOnPath(command) {
+    if (command.includes('/') && existsSync(command))
+        return command;
+    for (const dir of (process.env.PATH ?? '').split(delimiter).filter(Boolean)) {
+        const candidate = join(dir, command);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+function splitCommandLine(commandLine) {
+    return commandLine.trim().split(/\s+/).filter(Boolean);
+}
+function truncateText(value, maxLength) {
+    const compact = value.replace(/\s+/g, ' ').trim();
+    return compact.length > maxLength ? `${compact.slice(0, maxLength - 1)}...` : compact;
+}
+export function scanHarness(options = {}) {
+    const rootDir = resolve(options.rootDir ?? process.cwd());
+    const skipped = [];
+    const files = inventoryFiles(rootDir, skipped);
+    const annotations = files.flatMap((file) => parseAnnotations(file));
+    const repo = detectRepo(rootDir, files);
+    const readPlan = buildHarnessReadPlan(rootDir, options.pathWasExplicit === true);
+    const graph = {
+        schemaVersion: SCHEMA_VERSION,
+        harnessId: stableId('harness', repo.name || basename(rootDir) || 'repo'),
+        tenant: options.tenantId
+            ? {
+                tenantId: options.tenantId,
+                source: options.tenantSource ?? 'scan_option',
+            }
+            : undefined,
+        repo,
+        scan: {
+            createdAt: new Date().toISOString(),
+            scannerVersion: options.scannerVersion ?? 'moda-cli',
+            mode: options.dryRun ? 'dry-run' : 'permissioned',
+            rootPaths: ['.'],
+            readPlan,
+            skipped,
+        },
+        agentFamilies: [],
+        runtimeAgents: [],
+        developerAgentAdapters: detectDeveloperAgentAdapters(files),
+        channelAdapters: [],
+        artifacts: [],
+        identityNamespaces: [],
+        environments: detectEnvironments(files),
+        agentFrameworks: detectAgentFrameworks(files),
+        modelProviders: detectModelProviders(files),
+        deployments: [],
+        relationships: [],
+        unknowns: [],
+    };
+    applyAnnotations(graph, annotations);
+    applyHeuristics(graph, files);
+    linkFrameworksAndProviders(graph);
+    finalizeGraph(graph);
+    return graph;
+}
+export function summarizeHarness(graph) {
+    return {
+        schemaVersion: graph.schemaVersion,
+        harnessId: graph.harnessId,
+        tenantId: graph.tenant?.tenantId,
+        runtimeAgentCount: graph.runtimeAgents.length,
+        agentFamilyCount: graph.agentFamilies.length,
+        sharedArtifactCount: graph.artifacts.filter((artifact) => artifact.scope === 'shared').length,
+        channelAdapterCount: graph.channelAdapters.length,
+        identityNamespaceCount: graph.identityNamespaces.length,
+        agentFrameworkCount: graph.agentFrameworks.length,
+        modelProviderCount: graph.modelProviders.length,
+        deploymentCount: graph.deployments.length,
+        unknownCount: graph.unknowns.length,
+    };
+}
+function buildCommandScanPlan(context, rootDir) {
+    const explicitPath = context.flags.path !== undefined;
+    const rel = normalizePath(relative(context.cwd, rootDir)) || '.';
+    const scope = explicitPath && rel !== '.' ? 'narrow' : 'broad';
+    const machineReadable = context.outputMode !== 'human';
+    const approvalRequired = scope === 'broad' && !context.yes && !machineReadable && process.stdin.isTTY === true;
+    return {
+        scope,
+        root: rel,
+        approval: {
+            required: approvalRequired,
+            granted: !approvalRequired,
+            reason: approvalRequired
+                ? 'broad scan requires confirmation'
+                : machineReadable
+                    ? 'machine-readable output'
+                    : context.yes
+                        ? '--yes'
+                        : scope === 'narrow'
+                            ? 'narrow path'
+                            : 'non-interactive terminal',
+        },
+        readPlan: buildHarnessReadPlan(rootDir, explicitPath),
+    };
+}
+async function approveScanIfNeeded(scanPlan, options = {}) {
+    if (!scanPlan.approval.required)
+        return;
+    if (options.context?.outputMode === 'human') {
+        writeHumanBlock(options.context, renderHarnessAnalystPreflight({
+            root: scanPlan.root,
+            willRead: scanPlan.readPlan.willRead,
+            willSkip: scanPlan.readPlan.willSkip,
+        }));
+    }
+    const approved = await confirm({
+        message: options.message ?? 'Scan this project to build a Moda harness manifest?',
+        default: true,
+    });
+    scanPlan.approval.granted = approved;
+    scanPlan.approval.reason = approved ? 'confirmed by user' : 'declined by user';
+    if (!approved) {
+        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) {
+    if (context.outputMode !== 'human')
+        return;
+    if (context.quiet && context.flags.progress !== 'true')
+        return;
+    console.error(renderHarnessProgress(message));
+}
+function writeHumanBlock(context, message) {
+    if (context.outputMode !== 'human')
+        return;
+    if (context.quiet && context.flags.progress !== 'true')
+        return;
+    console.error(message);
+}
+function buildHarnessReadPlan(rootDir, pathWasExplicit) {
+    return {
+        scope: pathWasExplicit ? 'narrow' : 'broad',
+        rootPaths: [normalizePath(relative(rootDir, rootDir)) || '.'],
+        willRead: [
+            'package manifests',
+            'source files under the selected path',
+            'prompt files',
+            'tool definitions',
+            'skill/rule files',
+            'eval/test files',
+            'deployment and CI config',
+        ],
+        willSkip: [
+            'secret-looking files',
+            'symlinks',
+            'node_modules and build output',
+            '.moda runtime files',
+            'large files over 512KB',
+        ],
+        skipsSecretFiles: true,
+        followsSymlinks: false,
+        uploadsSourceByDefault: false,
+    };
+}
+function resolveHarnessTenant(flags, context) {
+    const flagTenant = flags['tenant-id'] || flags.tenant;
+    if (flagTenant && flagTenant !== 'true') {
+        return {
+            tenantId: flagTenant,
+            source: 'flag',
+        };
+    }
+    const tenantId = resolveTenantId({ profile: context?.profile, env: context?.env });
+    if (!tenantId)
+        return undefined;
+    return {
+        tenantId,
+        source: 'env_or_config',
+    };
+}
+function createHarnessSyncPlan(options) {
+    const profile = getActiveProfile({
+        profile: options.context.profile,
+        env: options.context.env,
+    });
+    const tenantId = options.graph.tenant?.tenantId ??
+        resolveTenantId({ profile: options.context.profile, env: options.context.env });
+    return {
+        endpoint: '/api/harnesses/sync',
+        resource: 'harness',
+        source: options.source,
+        profile: profile.name,
+        tenantId,
+        rootPath: options.rootDir,
+        sourceCommit: options.sourceCommit,
+        harnessId: options.graph.harnessId,
+        localGraphHash: options.localGraphHash,
+        counts: syncCounts(options.graph),
+        uploads: options.source === 'approved_report'
+            ? [
+                'approved harness graph metadata',
+                'runtime agents, families, artifacts, relationships, citations-derived graph shape',
+                'graph hash and source commit',
+            ]
+            : [
+                'harness graph metadata',
+                'runtime agents, families, artifacts, relationships',
+                'graph hash and source commit',
+            ],
+        localWrites: options.localWrites,
+        privacy: [
+            'No secret-looking files are read by the harness scanner.',
+            'Source file contents are not uploaded by harness sync by default.',
+            'Prompt/tool/skill artifacts sync as metadata, ids, paths, hashes, and relationships unless a separate resource command uploads content.',
+        ],
+    };
+}
+function plannedHarnessArtifactWrites(context) {
+    return context.flags.summary === 'true'
+        ? [HARNESS_PATH, HARNESS_SUMMARY_PATH, SYNC_STATE_PATH]
+        : [HARNESS_PATH, SYNC_STATE_PATH];
+}
+function syncCounts(graph) {
+    return {
+        runtimeAgents: graph.runtimeAgents.length,
+        agentFamilies: graph.agentFamilies.length,
+        developerAgentAdapters: graph.developerAgentAdapters.length,
+        channelAdapters: graph.channelAdapters.length,
+        artifacts: graph.artifacts.length,
+        identityNamespaces: graph.identityNamespaces.length,
+        environments: graph.environments.length,
+        agentFrameworks: graph.agentFrameworks.length,
+        modelProviders: graph.modelProviders.length,
+        deployments: graph.deployments.length,
+        relationships: graph.relationships.length,
+        unknowns: graph.unknowns.length,
+    };
+}
+function plannedDryRunRemote(plan) {
+    return {
+        tenantId: plan.tenantId ?? 'unresolved',
+        harnessId: plan.harnessId,
+        harnessKey: plan.harnessId,
+        versionId: '',
+        graphHash: plan.localGraphHash,
+        changed: false,
+        dryRun: true,
+        counts: plan.counts,
+    };
+}
+async function syncHarnessWithRemote(context, body) {
+    const profileOptions = { profile: context.profile, env: context.env };
+    const hasApiKey = Boolean(resolveApiKey(profileOptions));
+    if (context.dryRun && !hasApiKey)
+        return undefined;
+    return await callControlAPI('/harnesses/sync', {
+        method: 'POST',
+        body: JSON.stringify({
+            ...body,
+            dryRun: context.dryRun,
+        }),
+    }, profileOptions);
+}
+export function readHarnessSyncState(rootDir) {
+    const path = join(rootDir, SYNC_STATE_PATH);
+    if (!existsSync(path))
+        return undefined;
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (!isRecord(parsed) || parsed.schemaVersion !== 'sync_state.v0.1') {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeHarnessSyncState(rootDir, state) {
+    const path = join(rootDir, SYNC_STATE_PATH);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state, null, 2)}\n`);
+    return SYNC_STATE_PATH;
+}
+function selectedRuntimeAgentId(flags) {
+    if (flags['agent-id'])
+        return flags['agent-id'];
+    if (flags.agent && flags.agent !== 'true')
+        return flags.agent;
+    return undefined;
+}
+function loadOrScanHarness(rootDir, tenant) {
+    const manifestPath = join(rootDir, HARNESS_PATH);
+    return existsSync(manifestPath)
+        ? readHarnessGraph(manifestPath)
+        : scanHarness({
+            rootDir,
+            tenantId: tenant?.tenantId,
+            tenantSource: tenant?.source,
+        });
+}
+function readHarnessGraph(manifestPath) {
+    return JSON.parse(readFileSync(manifestPath, 'utf8'));
+}
+function writeHarnessArtifacts(graph, rootDir, options = {}) {
+    const modaDir = join(rootDir, MODA_DIR);
+    mkdirSync(modaDir, { recursive: true });
+    const manifestPath = join(rootDir, HARNESS_PATH);
+    writeFileSync(manifestPath, `${JSON.stringify(graph, null, 2)}\n`);
+    const written = [HARNESS_PATH];
+    if (options.summary) {
+        written.push(writeHarnessSummary(graph, rootDir));
+    }
+    return written;
+}
+function writeHarnessSummary(graph, rootDir) {
+    const summaryPath = join(rootDir, HARNESS_SUMMARY_PATH);
+    mkdirSync(dirname(summaryPath), { recursive: true });
+    writeFileSync(summaryPath, renderHarnessMarkdown(graph));
+    return HARNESS_SUMMARY_PATH;
+}
+function renderHarnessMarkdown(graph) {
+    const summary = summarizeHarness(graph);
+    const lines = [
+        '# Moda Harness',
+        '',
+        `Harness ID: ${graph.harnessId}`,
+        `Tenant ID: ${graph.tenant?.tenantId ?? 'none'}`,
+        `Runtime agents: ${summary.runtimeAgentCount}`,
+        `Agent families: ${summary.agentFamilyCount}`,
+        `Shared artifacts: ${summary.sharedArtifactCount}`,
+        `Channel adapters: ${summary.channelAdapterCount}`,
+        `Identity namespaces: ${summary.identityNamespaceCount}`,
+        `Agent frameworks: ${summary.agentFrameworkCount}`,
+        `Model providers: ${summary.modelProviderCount}`,
+        '',
+        '## What This Harness Does',
+        '',
+        ...renderHarnessPurposeLines(graph),
+        '',
+        '## Frameworks And Models',
+        '',
+        ...renderFrameworkAndProviderLines(graph),
+        '',
+        '## Moda Data Flow',
+        '',
+        '- `moda harness scan` reads local harness structure and writes `.moda/harness.json`.',
+        '- `moda harness sync` uploads the graph metadata, hashes, and relationships to Moda Cloud.',
+        '- Prompt, skill, eval, deployment, framework, and provider detections become the local context Moda uses for future recommendations.',
+        '- Source content and secret-bearing files are not uploaded by default during scan.',
+        '',
+        '## Runtime Agents',
+        '',
+    ];
+    for (const agent of graph.runtimeAgents) {
+        const artifacts = graph.artifacts.filter((artifact) => agent.artifactIds.includes(artifact.id));
+        lines.push(`### ${agent.name}`, '', `- ID: ${agent.id}`, `- Root: ${agent.root}`, `- Purpose: ${agent.purpose ?? 'unknown'}`, `- Family: ${agent.familyId ?? 'none'}`, `- Channels: ${agent.channelAdapterIds.join(', ') || 'none'}`, `- Frameworks: ${(agent.frameworkIds ?? []).join(', ') || 'unknown'}`, `- Model providers: ${(agent.modelProviderIds ?? []).join(', ') || 'unknown'}`, `- Artifacts: ${artifacts.map((artifact) => artifact.name).join(', ') || 'none'}`, `- Confidence: ${agent.confidence.toFixed(2)}`, '');
+    }
+    if (graph.agentFamilies.length > 0) {
+        lines.push('## Agent Families', '');
+        for (const family of graph.agentFamilies) {
+            lines.push(`### ${family.name}`, '', `- ID: ${family.id}`, `- Agents: ${family.runtimeAgentIds.join(', ') || 'none'}`, `- Shared artifacts: ${family.sharedArtifactIds.join(', ') || 'none'}`, '');
+        }
+    }
+    if (graph.unknowns.length > 0) {
+        lines.push('## Open Questions', '');
+        for (const unknown of graph.unknowns) {
+            lines.push(`- ${unknown.question}`);
+        }
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function renderHarnessPurposeLines(graph) {
+    if (graph.runtimeAgents.length === 0) {
+        return ['- No runtime agents were confidently detected yet.'];
+    }
+    return graph.runtimeAgents.map((agent) => {
+        const channels = agent.channelAdapterIds
+            .map((id) => graph.channelAdapters.find((channel) => channel.id === id)?.name ?? titleFromId(id))
+            .join(', ');
+        const purpose = agent.purpose ?? inferPurposeFromAgentShape(graph, agent);
+        return `- ${agent.name}: ${purpose}${channels ? ` (${channels})` : ''}.`;
+    });
+}
+function inferPurposeFromAgentShape(graph, agent) {
+    const prompts = graph.artifacts
+        .filter((artifact) => agent.artifactIds.includes(artifact.id) && artifact.type === 'prompt')
+        .map((artifact) => artifact.name);
+    if (prompts.length > 0)
+        return `Uses ${prompts.join(', ')}`;
+    if (agent.channelAdapterIds.length > 0) {
+        return `Handles ${agent.channelAdapterIds.map((id) => titleFromId(id)).join(', ')} traffic`;
+    }
+    return 'Runtime agent detected from local code';
+}
+function renderFrameworkAndProviderLines(graph) {
+    const lines = [];
+    if (graph.agentFrameworks.length > 0) {
+        lines.push(`- Frameworks: ${graph.agentFrameworks.map((framework) => framework.name).join(', ')}`);
+    }
+    else {
+        lines.push('- Frameworks: unknown');
+    }
+    if (graph.modelProviders.length > 0) {
+        lines.push(`- Model providers: ${graph.modelProviders.map((provider) => provider.name).join(', ')}`);
+        for (const provider of graph.modelProviders) {
+            if (provider.modelHints.length > 0) {
+                lines.push(`- ${provider.name} model hints: ${provider.modelHints.join(', ')}`);
+            }
+        }
+    }
+    else {
+        lines.push('- Model providers: unknown');
+    }
+    return lines;
+}
+export function graphForSync(graph) {
+    return sortJson({
+        ...graph,
+        scan: {
+            ...graph.scan,
+            createdAt: undefined,
+            scannerVersion: undefined,
+            skipped: undefined,
+        },
+    });
+}
+function hashStableJson(value) {
+    return hashText(JSON.stringify(sortJson(value)));
+}
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map((item) => sortJson(item));
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => [key, sortJson(item)]));
+    }
+    return value;
+}
+function getGitCommit(rootDir) {
+    try {
+        return execFileSync('git', ['rev-parse', 'HEAD'], {
+            cwd: rootDir,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function explainAgent(graph, agent) {
+    return {
+        agent,
+        family: agent.familyId
+            ? graph.agentFamilies.find((family) => family.id === agent.familyId) ?? null
+            : null,
+        channels: graph.channelAdapters.filter((channel) => agent.channelAdapterIds.includes(channel.id)),
+        artifacts: graph.artifacts.filter((artifact) => agent.artifactIds.includes(artifact.id)),
+        identities: graph.identityNamespaces.filter((identity) => agent.identityNamespaceIds.includes(identity.id)),
+        deployments: graph.deployments.filter((deployment) => agent.deploymentIds.includes(deployment.id)),
+        relationships: graph.relationships.filter((relationship) => relationship.from === agent.id || relationship.to === agent.id),
+    };
+}
+function inventoryFiles(rootDir, skipped) {
+    const files = [];
+    const rootReal = resolve(rootDir);
+    const maxFiles = numericEnv('MODA_HARNESS_MAX_FILES', DEFAULT_MAX_INVENTORY_FILES);
+    const maxTextBytes = numericEnv('MODA_HARNESS_MAX_TEXT_BYTES', DEFAULT_MAX_INVENTORY_TEXT_BYTES);
+    let textBytes = 0;
+    function walk(current) {
+        const rel = normalizePath(relative(rootReal, current)) || '.';
+        let stat;
+        try {
+            stat = lstatSync(current);
+        }
+        catch {
+            recordSkipped(skipped, { path: rel, reason: 'stat failed' });
+            return;
+        }
+        if (stat.isSymbolicLink()) {
+            recordSkipped(skipped, { path: rel, reason: 'symlink skipped for safety' });
+            return;
+        }
+        if (stat.isDirectory()) {
+            if (rel !== '.' && shouldSkipDirectory(rel, current)) {
+                recordSkipped(skipped, { path: rel, reason: 'ignored directory' });
+                return;
+            }
+            for (const entry of readdirSync(current).sort()) {
+                walk(join(current, entry));
+            }
+            return;
+        }
+        if (!stat.isFile())
+            return;
+        if (stat.size > MAX_SCANNED_FILE_BYTES) {
+            recordSkipped(skipped, { path: rel, reason: 'file too large for harness scan' });
+            return;
+        }
+        if (isSecretishPath(rel)) {
+            recordSkipped(skipped, { path: rel, reason: 'secret-bearing file skipped' });
+            return;
+        }
+        if (!shouldInventoryFile(rel))
+            return;
+        if (files.length >= maxFiles) {
+            throwHarnessScanTooBroad(rootReal, {
+                files: files.length,
+                textBytes,
+                lastPath: rel,
+                maxFiles,
+                maxTextBytes,
+            });
+        }
+        const item = { path: rel, absPath: current, rootDir: rootReal };
+        if (isTextFile(rel)) {
+            if (textBytes + stat.size > maxTextBytes) {
+                recordSkipped(skipped, { path: rel, reason: 'scan text budget exceeded' });
+            }
+            else {
+                try {
+                    item.text = readFileSync(current, 'utf8');
+                    textBytes += Buffer.byteLength(item.text, 'utf8');
+                }
+                catch {
+                    recordSkipped(skipped, { path: rel, reason: 'text read failed' });
+                }
+            }
+        }
+        files.push(item);
+    }
+    walk(rootReal);
+    return files;
+}
+function shouldSkipDirectory(rel, absPath) {
+    if (SKIPPED_DIRS.has(basename(absPath)))
+        return true;
+    return SKIPPED_PATH_PREFIXES.some((prefix) => rel === prefix || rel.startsWith(`${prefix}/`));
+}
+function shouldInventoryFile(path) {
+    const normalized = normalizePath(path);
+    const base = basename(normalized);
+    const ext = extname(normalized).toLowerCase();
+    if (isSourceFile(normalized))
+        return true;
+    if (isPackageOrLockfile(normalized))
+        return true;
+    if (isPromptLikePath(normalized))
+        return true;
+    if (isSkillLikePath(normalized))
+        return true;
+    if (isEvalLikePath(normalized))
+        return true;
+    if (isDeploymentLikePath(normalized))
+        return true;
+    if (isDeveloperAgentConfigPath(normalized))
+        return true;
+    if (base === 'README.md' || base === 'AGENTS.md')
+        return true;
+    return ext === '.toml' && (base === 'pyproject.toml' || base === 'wrangler.toml');
+}
+function isSourceFile(path) {
+    return /\.(ts|tsx|js|jsx|mjs|cjs|py)$/i.test(path);
+}
+function isPackageOrLockfile(path) {
+    return path === 'package.json' ||
+        path === 'pyproject.toml' ||
+        path === 'bun.lock' ||
+        path === 'bun.lockb' ||
+        path === 'pnpm-lock.yaml' ||
+        path === 'yarn.lock';
+}
+function isPromptLikePath(path) {
+    return /(^|\/)prompts?\//i.test(path) &&
+        /\.(prompt\.)?(md|json|ya?ml)$/i.test(path);
+}
+function isSkillLikePath(path) {
+    return /(^|\/)(\.claude\/skills|\.cursor\/rules|skills?)\//i.test(path) &&
+        /\.(md|mdc)$/i.test(path);
+}
+function isEvalLikePath(path) {
+    return /(^|\/)(evals?|tests?|__tests__)\//i.test(path) &&
+        /\.(ts|tsx|js|mjs|py|json|ya?ml)$/i.test(path);
+}
+function isDeploymentLikePath(path) {
+    return /(^|\/)(wrangler\.toml|vercel\.json|render\.ya?ml|railway\.json|Dockerfile|docker-compose\.ya?ml)$/i.test(path) ||
+        /^\.github\/workflows\/[^/]+\.ya?ml$/i.test(path);
+}
+function isDeveloperAgentConfigPath(path) {
+    return path === '.claude/settings.json' ||
+        path === '.codex/hooks.json' ||
+        path === '.cursor/hooks.json';
+}
+function recordSkipped(skipped, item) {
+    if (skipped.length < MAX_RECORDED_SKIPS) {
+        skipped.push(item);
+        return;
+    }
+    if (skipped.length === MAX_RECORDED_SKIPS) {
+        skipped.push({
+            path: '...',
+            reason: 'additional skipped entries omitted',
+        });
+    }
+}
+function throwHarnessScanTooBroad(rootDir, details) {
+    const mib = (details.textBytes / 1024 / 1024).toFixed(1);
+    const maxMib = (details.maxTextBytes / 1024 / 1024).toFixed(0);
+    throw new CliInputError('Harness scan is too broad for safe local analysis.', [
+        `Moda reached ${details.files.toLocaleString()} files while scanning ${rootDir}.`,
+        `Text read budget: ${mib}MiB of ${maxMib}MiB. Last path: ${details.lastPath}.`,
+        'Run `moda init` from the actual agent project root, not a parent folder like ~/Projects.',
+        'For harness-only analysis, use `moda harness analyze --path=<agent-dir> --summary`.',
+    ].join('\n'));
+}
+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) {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number(raw);
+    return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : fallback;
+}
+function isTextFile(path) {
+    const ext = extname(path).toLowerCase();
+    return [
+        '',
+        '.cjs',
+        '.js',
+        '.json',
+        '.jsx',
+        '.md',
+        '.mdc',
+        '.mjs',
+        '.py',
+        '.toml',
+        '.ts',
+        '.tsx',
+        '.txt',
+        '.yaml',
+        '.yml',
+    ].includes(ext);
+}
+function isSecretishPath(path) {
+    const name = basename(path).toLowerCase();
+    return name === '.env' ||
+        name.startsWith('.env.') ||
+        name.includes('secret') ||
+        name.includes('private-key') ||
+        name.endsWith('.pem');
+}
+function detectRepo(rootDir, files) {
+    const packageJson = files.find((file) => file.path === 'package.json');
+    const pyproject = files.find((file) => file.path === 'pyproject.toml');
+    const name = packageJson?.text
+        ? safePackageName(packageJson.text) ?? basename(rootDir)
+        : pyproject?.text
+            ? safeTomlName(pyproject.text) ?? basename(rootDir)
+            : basename(rootDir);
+    const packageManagers = [
+        files.some((file) => file.path === 'bun.lock' || file.path === 'bun.lockb') ? 'bun' : null,
+        files.some((file) => file.path === 'pnpm-lock.yaml') ? 'pnpm' : null,
+        files.some((file) => file.path === 'yarn.lock') ? 'yarn' : null,
+        packageJson ? 'npm' : null,
+        pyproject ? 'python' : null,
+    ].filter((value) => Boolean(value));
+    const languages = [
+        files.some((file) => file.path.endsWith('.ts') || file.path.endsWith('.tsx')) ? 'typescript' : null,
+        files.some((file) => file.path.endsWith('.js') || file.path.endsWith('.jsx') || file.path.endsWith('.mjs')) ? 'javascript' : null,
+        files.some((file) => file.path.endsWith('.py')) ? 'python' : null,
+    ].filter((value) => Boolean(value));
+    return {
+        root: '.',
+        name,
+        packageManagers: [...new Set(packageManagers)],
+        languages: [...new Set(languages)],
+    };
+}
+function safePackageName(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed.name === 'string' ? parsed.name : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeTomlName(text) {
+    const match = text.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
+    return match?.[1];
+}
+function parseAnnotations(file) {
+    if (!file.text?.includes('moda:'))
+        return [];
+    const annotations = [];
+    const lines = file.text.split(/\r?\n/);
+    lines.forEach((line, index) => {
+        const match = line.match(/\bmoda:\s*([a-z-]+)\s*(.*)$/i);
+        if (!match)
+            return;
+        annotations.push({
+            type: match[1],
+            values: parseAnnotationValues(match[2] ?? ''),
+            evidence: {
+                path: file.path,
+                reason: `Explicit moda ${match[1]} annotation on line ${index + 1}.`,
+            },
+            sourceAbsPath: file.absPath,
+            rootDir: file.rootDir,
+        });
+    });
+    return annotations;
+}
+function parseAnnotationValues(raw) {
+    const values = {};
+    const regex = /([A-Za-z0-9_-]+)=("([^"]*)"|'([^']*)'|[^\s]+)/g;
+    let match;
+    while ((match = regex.exec(raw))) {
+        const key = match[1].replace(/-/g, '_');
+        const value = match[3] ?? match[4] ?? match[2];
+        if (!values[key])
+            values[key] = [];
+        values[key].push(value);
+    }
+    return values;
+}
+function applyAnnotations(graph, annotations) {
+    for (const annotation of annotations) {
+        switch (annotation.type) {
+            case 'runtime-agent':
+            case 'agent':
+                upsertRuntimeAgent(graph, runtimeAgentFromAnnotation(annotation));
+                break;
+            case 'agent-family':
+            case 'family':
+                upsertAgentFamily(graph, agentFamilyFromAnnotation(annotation));
+                break;
+            case 'channel':
+                upsertChannel(graph, channelFromAnnotation(annotation));
+                break;
+            case 'artifact':
+                upsertArtifact(graph, artifactFromAnnotation(annotation));
+                break;
+            case 'identity':
+                upsertIdentity(graph, identityFromAnnotation(annotation));
+                break;
+            case 'deployment':
+                upsertDeployment(graph, deploymentFromAnnotation(annotation));
+                break;
+            case 'environment':
+                upsertEnvironment(graph, environmentFromAnnotation(annotation));
+                break;
+            default:
+                graph.unknowns.push({
+                    id: stableId('unknown', `${annotation.type}-${annotation.evidence.path}`),
+                    question: `Unknown moda annotation type '${annotation.type}' in ${annotation.evidence.path}.`,
+                    candidateIds: [],
+                    evidence: [annotation.evidence],
+                });
+        }
+    }
+}
+function runtimeAgentFromAnnotation(annotation) {
+    const values = annotation.values;
+    const id = first(values.id) ?? stableId('agent', first(values.name) ?? annotation.evidence.path);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        kind: 'runtime_agent',
+        purpose: first(values.purpose) ?? first(values.description),
+        familyId: first(values.family),
+        root: normalizePath(first(values.root) ?? dirname(annotation.evidence.path)),
+        entrypointIds: values.entrypoint ?? [stableId('entry', annotation.evidence.path)],
+        channelAdapterIds: values.channel ?? [],
+        artifactIds: [...(values.artifact ?? []), ...(values.prompt ?? []), ...(values.tool ?? [])],
+        identityNamespaceIds: values.identity ?? [],
+        deploymentIds: values.deployment ?? [],
+        frameworkIds: values.framework ?? [],
+        modelProviderIds: [...(values.provider ?? []), ...(values.model_provider ?? [])],
+        confidence: numberValue(first(values.confidence), 0.9),
+        evidence: [annotation.evidence],
+    };
+}
+function agentFamilyFromAnnotation(annotation) {
+    const values = annotation.values;
+    const id = first(values.id) ?? stableId('family', first(values.name) ?? annotation.evidence.path);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        description: first(values.description),
+        runtimeAgentIds: values.agent ?? [],
+        sharedArtifactIds: [...(values.artifact ?? []), ...(values.prompt ?? []), ...(values.tool ?? [])],
+        confidence: numberValue(first(values.confidence), 0.86),
+        evidence: [annotation.evidence],
+    };
+}
+function channelFromAnnotation(annotation) {
+    const values = annotation.values;
+    const kind = first(values.kind) ?? first(values.type) ?? 'channel';
+    const id = first(values.id) ?? stableId('channel', first(values.name) ?? kind);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        kind,
+        sourcePath: annotation.evidence.path,
+        confidence: numberValue(first(values.confidence), 0.85),
+        evidence: [annotation.evidence],
+    };
+}
+function artifactFromAnnotation(annotation) {
+    const values = annotation.values;
+    const type = artifactType(first(values.kind) ?? first(values.type));
+    const sourcePath = first(values.path) ?? annotation.evidence.path;
+    const id = first(values.id) ?? stableId(type, first(values.name) ?? sourcePath);
+    return {
+        id,
+        type,
+        name: first(values.name) ?? titleFromId(id),
+        scope: scopeValue(first(values.scope)),
+        sourcePath,
+        contentHash: contentHashForAnnotatedSource(sourcePath, annotation),
+        ownedByAgentId: first(values.owner),
+        usedByAgentIds: values.agent ?? [],
+        confidence: numberValue(first(values.confidence), 0.85),
+        evidence: [annotation.evidence],
+    };
+}
+function identityFromAnnotation(annotation) {
+    const values = annotation.values;
+    const kind = first(values.kind) ?? first(values.type) ?? 'identity';
+    const id = first(values.id) ?? stableId('identity', first(values.name) ?? kind);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        kind,
+        canonicalId: first(values.canonical),
+        sourcePath: annotation.evidence.path,
+        confidence: numberValue(first(values.confidence), 0.8),
+        evidence: [annotation.evidence],
+    };
+}
+function deploymentFromAnnotation(annotation) {
+    const values = annotation.values;
+    const id = first(values.id) ?? stableId('deploy', first(values.name) ?? annotation.evidence.path);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        environmentId: first(values.environment),
+        sourcePath: first(values.path) ?? annotation.evidence.path,
+        confidence: numberValue(first(values.confidence), 0.78),
+        evidence: [annotation.evidence],
+    };
+}
+function environmentFromAnnotation(annotation) {
+    const values = annotation.values;
+    const kind = first(values.kind) ?? first(values.type) ?? 'runtime';
+    const id = first(values.id) ?? stableId('env', first(values.name) ?? kind);
+    return {
+        id,
+        name: first(values.name) ?? titleFromId(id),
+        kind,
+        sourcePath: annotation.evidence.path,
+        confidence: numberValue(first(values.confidence), 0.75),
+        evidence: [annotation.evidence],
+    };
+}
+function applyHeuristics(graph, files) {
+    for (const file of files) {
+        maybeAddPromptArtifact(graph, file);
+        maybeAddSkillArtifact(graph, file);
+        maybeAddEvalArtifact(graph, file);
+        maybeAddDeployment(graph, file);
+    }
+    if (graph.runtimeAgents.length === 0) {
+        for (const file of files) {
+            const agent = inferRuntimeAgent(file, graph);
+            if (agent)
+                upsertRuntimeAgent(graph, agent);
+        }
+    }
+    for (const agent of graph.runtimeAgents) {
+        if (agent.entrypointIds.length === 0) {
+            const entryId = stableId('entry', agent.root);
+            agent.entrypointIds.push(entryId);
+            upsertArtifact(graph, {
+                id: entryId,
+                type: 'entrypoint',
+                name: `${agent.name} Entrypoint`,
+                scope: 'agent',
+                sourcePath: agent.root,
+                ownedByAgentId: agent.id,
+                usedByAgentIds: [agent.id],
+                confidence: 0.7,
+                evidence: agent.evidence,
+            });
+        }
+    }
+}
+function maybeAddPromptArtifact(graph, file) {
+    const isPrompt = /(^|\/)prompts?\//i.test(file.path) &&
+        /\.(prompt\.)?(md|json|ya?ml)$/i.test(file.path);
+    if (!isPrompt)
+        return;
+    const id = stableId('prompt', file.path);
+    upsertArtifact(graph, {
+        id,
+        type: 'prompt',
+        name: promptNameFromPath(file.path),
+        scope: 'agent',
+        sourcePath: file.path,
+        contentHash: hashText(file.text ?? readFileSync(file.absPath, 'utf8')),
+        usedByAgentIds: [],
+        confidence: 0.72,
+        evidence: [{ path: file.path, reason: 'Prompt-like file found under prompts directory.' }],
+    });
+}
+function maybeAddSkillArtifact(graph, file) {
+    if (!/(^|\/)(\.claude\/skills|\.cursor\/rules|skills?)\//i.test(file.path))
+        return;
+    if (!/\.(md|mdc)$/i.test(file.path))
+        return;
+    upsertArtifact(graph, {
+        id: stableId('skill', file.path),
+        type: 'skill',
+        name: titleFromId(basename(file.path).replace(/\.(md|mdc)$/i, '')),
+        scope: 'global',
+        sourcePath: file.path,
+        contentHash: hashText(file.text ?? ''),
+        usedByAgentIds: [],
+        confidence: 0.7,
+        evidence: [{ path: file.path, reason: 'Skill or rule file detected.' }],
+    });
+}
+function maybeAddEvalArtifact(graph, file) {
+    if (!/(eval|test|spec)/i.test(file.path))
+        return;
+    if (!/\.(ts|tsx|js|mjs|py|json|ya?ml)$/i.test(file.path))
+        return;
+    upsertArtifact(graph, {
+        id: stableId('eval', file.path),
+        type: 'eval',
+        name: titleFromId(file.path),
+        scope: 'global',
+        sourcePath: file.path,
+        contentHash: file.text ? hashText(file.text) : undefined,
+        usedByAgentIds: [],
+        confidence: 0.52,
+        evidence: [{ path: file.path, reason: 'Eval/test-like file detected.' }],
+    });
+}
+function maybeAddDeployment(graph, file) {
+    if (!/(wrangler\.toml|vercel\.json|render\.yaml|railway\.json|Dockerfile|docker-compose\.ya?ml|\.github\/workflows\/)/i.test(file.path)) {
+        return;
+    }
+    upsertDeployment(graph, {
+        id: stableId('deploy', file.path),
+        name: titleFromId(file.path),
+        sourcePath: file.path,
+        confidence: 0.6,
+        evidence: [{ path: file.path, reason: 'Deployment or CI configuration detected.' }],
+    });
+}
+function inferRuntimeAgent(file, graph) {
+    if (!file.text)
+        return null;
+    if (!/\.(ts|tsx|js|mjs|py)$/i.test(file.path))
+        return null;
+    if (basename(file.path) === '__init__.py')
+        return null;
+    const loweredPath = file.path.toLowerCase();
+    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);
+    if (!pathLooksLikeAgent || !codeLooksLikeAgent)
+        return null;
+    const channelIds = inferChannels(file);
+    const artifactIds = inferArtifactsForFile(file, graph);
+    const frameworkIds = frameworkIdsForFile(file);
+    const modelProviderIds = providerIdsForFile(file);
+    const agentId = stableId('agent', file.path.replace(/\.(ts|tsx|js|mjs|py)$/i, ''));
+    const entryId = stableId('entry', file.path);
+    upsertArtifact(graph, {
+        id: entryId,
+        type: 'entrypoint',
+        name: `${titleFromId(agentId)} Entrypoint`,
+        scope: 'agent',
+        sourcePath: file.path,
+        contentHash: hashText(file.text),
+        ownedByAgentId: agentId,
+        usedByAgentIds: [agentId],
+        confidence: 0.7,
+        evidence: [{ path: file.path, reason: 'Agent-like entrypoint detected from path and code.' }],
+    });
+    return {
+        id: agentId,
+        name: titleFromId(file.path.replace(/\.(ts|tsx|js|mjs|py)$/i, '')),
+        kind: 'runtime_agent',
+        purpose: inferAgentPurpose(file),
+        root: normalizePath(dirname(file.path)),
+        entrypointIds: [entryId],
+        channelAdapterIds: channelIds,
+        artifactIds,
+        identityNamespaceIds: [],
+        deploymentIds: [],
+        frameworkIds,
+        modelProviderIds,
+        confidence: loweredText.includes('run_agent') || loweredText.includes('runagent') ? 0.68 : 0.56,
+        evidence: [{ path: file.path, reason: 'Agent-like entrypoint detected from path and code.' }],
+    };
+}
+function inferAgentPurpose(file) {
+    const text = file.text ?? '';
+    const promptMatch = text.match(/(?:systemPrompt|system_prompt|SYSTEM_PROMPT)\s*[:=]\s*["'`]([^"'`]{12,180})/);
+    const quoted = promptMatch?.[1];
+    if (quoted)
+        return titleCaseSentence(quoted.split(/[.!?]/)[0]);
+    const commentMatch = text.match(/(?:purpose|description)\s*[:=]\s*["'`]([^"'`]{12,180})/i);
+    if (commentMatch?.[1])
+        return titleCaseSentence(commentMatch[1].split(/[.!?]/)[0]);
+    const path = file.path.toLowerCase();
+    if (path.includes('support'))
+        return 'Support Agent';
+    if (path.includes('triage'))
+        return 'Triage Agent';
+    if (path.includes('coding'))
+        return 'Coding Agent';
+    return undefined;
+}
+function titleCaseSentence(value) {
+    return value
+        .replace(/\s+/g, ' ')
+        .trim()
+        .split(' ')
+        .map((word) => {
+        if (!word)
+            return word;
+        if (/^[A-Z0-9_]+$/.test(word))
+            return word;
+        return word.charAt(0).toUpperCase() + word.slice(1);
+    })
+        .join(' ');
+}
+function inferChannels(file) {
+    const text = `${file.path}\n${file.text ?? ''}`.toLowerCase();
+    const channels = [
+        ['whatsapp', 'channel_whatsapp'],
+        ['sms', 'channel_sms'],
+        ['voice', 'channel_voice'],
+        ['slack', 'channel_slack'],
+        ['email', 'channel_email'],
+        ['web', 'channel_web'],
+        ['cron', 'channel_cron'],
+        ['api', 'channel_api'],
+    ];
+    return channels
+        .filter(([needle]) => text.includes(needle))
+        .map(([, id]) => id);
+}
+function inferArtifactsForFile(file, graph) {
+    const text = file.text ?? '';
+    const referenced = graph.artifacts.filter((artifact) => {
+        if (!artifact.sourcePath)
+            return false;
+        const base = basename(artifact.sourcePath);
+        return text.includes(base) || text.includes(artifact.sourcePath);
+    });
+    return referenced.map((artifact) => artifact.id);
+}
+function detectDeveloperAgentAdapters(files) {
+    const adapters = [];
+    if (files.some((file) => file.path.startsWith('.claude/'))) {
+        adapters.push({
+            id: 'developer_adapter_claude_code',
+            name: 'Claude Code',
+            kind: 'developer_agent_adapter',
+            sourcePath: '.claude',
+            confidence: 0.9,
+            evidence: [{ path: '.claude', reason: 'Claude Code project markers detected.' }],
+        });
+    }
+    if (files.some((file) => file.path.startsWith('.cursor/'))) {
+        adapters.push({
+            id: 'developer_adapter_cursor',
+            name: 'Cursor',
+            kind: 'developer_agent_adapter',
+            sourcePath: '.cursor',
+            confidence: 0.9,
+            evidence: [{ path: '.cursor', reason: 'Cursor project markers detected.' }],
+        });
+    }
+    if (files.some((file) => file.path.startsWith('.codex/'))) {
+        adapters.push({
+            id: 'developer_adapter_codex',
+            name: 'Codex',
+            kind: 'developer_agent_adapter',
+            sourcePath: '.codex',
+            confidence: 0.9,
+            evidence: [{ path: '.codex', reason: 'Codex project markers detected.' }],
+        });
+    }
+    return adapters;
+}
+function detectEnvironments(files) {
+    const envs = [];
+    for (const id of ['local', 'staging', 'prod']) {
+        const pathMatch = files.find((file) => file.path.includes(`.${id}.`) ||
+            file.path.includes(`-${id}.`) ||
+            file.path.includes(`/${id}/`));
+        if (pathMatch || id === 'local') {
+            envs.push({
+                id: `env_${id}`,
+                name: titleFromId(id),
+                kind: id,
+                sourcePath: pathMatch?.path,
+                confidence: pathMatch ? 0.65 : 0.45,
+                evidence: [{
+                        path: pathMatch?.path ?? '.',
+                        reason: pathMatch ? `Environment marker for ${id} detected.` : 'Default local environment assumed.',
+                    }],
+            });
+        }
+    }
+    return envs;
+}
+const FRAMEWORK_CATALOG = [
+    {
+        id: 'framework_langchain',
+        name: 'LangChain',
+        kind: 'agent_framework',
+        packageNames: ['langchain', '@langchain/core', '@langchain/langgraph', 'langgraph'],
+        patterns: [/langchain/i, /langgraph/i],
+    },
+    {
+        id: 'framework_vercel_ai_sdk',
+        name: 'Vercel AI SDK',
+        kind: 'agent_framework',
+        packageNames: ['ai', '@ai-sdk/openai', '@ai-sdk/anthropic'],
+        patterns: [/\bfrom\s+['"]ai['"]/, /\bgenerateText\s*\(/, /\bstreamText\s*\(/],
+    },
+    {
+        id: 'framework_mastra',
+        name: 'Mastra',
+        kind: 'agent_framework',
+        packageNames: ['mastra', '@mastra/core'],
+        patterns: [/mastra/i],
+    },
+    {
+        id: 'framework_openai_agents',
+        name: 'OpenAI Agents SDK',
+        kind: 'agent_framework',
+        packageNames: ['@openai/agents', 'openai-agents', 'openai-agents-python'],
+        patterns: [/openai_agents/i, /@openai\/agents/i, /\bAgent\s*\(/],
+    },
+    {
+        id: 'framework_crewai',
+        name: 'CrewAI',
+        kind: 'agent_framework',
+        packageNames: ['crewai'],
+        patterns: [/crewai/i],
+    },
+    {
+        id: 'framework_pydantic_ai',
+        name: 'Pydantic AI',
+        kind: 'agent_framework',
+        packageNames: ['pydantic-ai', 'pydantic_ai'],
+        patterns: [/pydantic_ai/i],
+    },
+];
+const PROVIDER_CATALOG = [
+    {
+        id: 'provider_openai',
+        name: 'OpenAI',
+        kind: 'model_provider',
+        packageNames: ['openai', '@ai-sdk/openai'],
+        envVars: ['OPENAI_API_KEY'],
+        patterns: [/from\s+['"]openai['"]/, /\bnew\s+OpenAI\b/, /\bgpt-[\w.-]+/i, /OPENAI_API_KEY/],
+    },
+    {
+        id: 'provider_anthropic',
+        name: 'Anthropic',
+        kind: 'model_provider',
+        packageNames: ['@anthropic-ai/sdk', '@ai-sdk/anthropic', 'anthropic'],
+        envVars: ['ANTHROPIC_API_KEY'],
+        patterns: [/anthropic/i, /\bclaude-[\w.-]+/i, /ANTHROPIC_API_KEY/],
+    },
+    {
+        id: 'provider_google',
+        name: 'Google Gemini',
+        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],
+    },
+    {
+        id: 'provider_cohere',
+        name: 'Cohere',
+        kind: 'model_provider',
+        packageNames: ['cohere-ai', 'cohere'],
+        envVars: ['COHERE_API_KEY'],
+        patterns: [/cohere/i],
+    },
+    {
+        id: 'provider_mistral',
+        name: 'Mistral',
+        kind: 'model_provider',
+        packageNames: ['@mistralai/mistralai', 'mistralai'],
+        envVars: ['MISTRAL_API_KEY'],
+        patterns: [/mistral/i],
+    },
+    {
+        id: 'provider_ollama',
+        name: 'Ollama',
+        kind: 'model_provider',
+        packageNames: ['ollama'],
+        envVars: ['OLLAMA_HOST'],
+        patterns: [/ollama/i],
+    },
+];
+function detectAgentFrameworks(files) {
+    const frameworks = [];
+    for (const candidate of FRAMEWORK_CATALOG) {
+        const evidence = detectionEvidence(files, candidate.packageNames, candidate.patterns);
+        if (evidence.length === 0)
+            continue;
+        frameworks.push({
+            id: candidate.id,
+            name: candidate.name,
+            kind: candidate.kind,
+            packageNames: [...candidate.packageNames],
+            runtimeAgentIds: [],
+            confidence: evidence.some((item) => item.path === 'package.json' || item.path === 'pyproject.toml') ? 0.82 : 0.66,
+            evidence,
+        });
+    }
+    return frameworks.sort((a, b) => a.id.localeCompare(b.id));
+}
+function detectModelProviders(files) {
+    const providers = [];
+    for (const candidate of PROVIDER_CATALOG) {
+        const evidence = detectionEvidence(files, candidate.packageNames, candidate.patterns);
+        if (evidence.length === 0)
+            continue;
+        const modelHints = modelHintsForProvider(candidate.id, files);
+        providers.push({
+            id: candidate.id,
+            name: candidate.name,
+            kind: candidate.kind,
+            packageNames: [...candidate.packageNames],
+            runtimeAgentIds: [],
+            envVars: [...candidate.envVars],
+            modelHints,
+            confidence: evidence.some((item) => item.path === 'package.json' || item.path === 'pyproject.toml') ? 0.82 : 0.62,
+            evidence,
+        });
+    }
+    return providers.sort((a, b) => a.id.localeCompare(b.id));
+}
+function detectionEvidence(files, packageNames, patterns) {
+    const evidence = [];
+    for (const file of files) {
+        if (file.path === 'package.json' && file.text) {
+            const deps = packageDependencyNames(file.text);
+            const matched = packageNames.filter((name) => deps.has(name));
+            for (const name of matched) {
+                evidence.push({ path: file.path, reason: `Dependency ${name} detected.` });
+            }
+        }
+        if (file.path === 'pyproject.toml' && file.text) {
+            const lowered = file.text.toLowerCase();
+            for (const name of packageNames) {
+                if (lowered.includes(name.toLowerCase())) {
+                    evidence.push({ path: file.path, reason: `Python dependency ${name} detected.` });
+                }
+            }
+        }
+        if (!file.text || !/\.(ts|tsx|js|mjs|py|json|toml)$/i.test(file.path))
+            continue;
+        for (const pattern of patterns) {
+            if (pattern.test(file.text)) {
+                evidence.push({ path: file.path, reason: `Source references ${pattern.source}.` });
+                break;
+            }
+        }
+    }
+    return mergeEvidence([], evidence).slice(0, 12);
+}
+function packageDependencyNames(text) {
+    try {
+        const parsed = JSON.parse(text);
+        return new Set([
+            ...Object.keys(parsed.dependencies ?? {}),
+            ...Object.keys(parsed.devDependencies ?? {}),
+            ...Object.keys(parsed.optionalDependencies ?? {}),
+            ...Object.keys(parsed.peerDependencies ?? {}),
+        ]);
+    }
+    catch {
+        return new Set();
+    }
+}
+function modelHintsForProvider(providerId, files) {
+    const hints = new Set();
+    const pattern = providerId === 'provider_anthropic'
+        ? /\bclaude-[A-Za-z0-9_.-]+/g
+        : providerId === 'provider_openai'
+            ? /\bgpt-[A-Za-z0-9_.-]+/g
+            : providerId === 'provider_google'
+                ? /\bgemini-[A-Za-z0-9_.-]+/g
+                : null;
+    if (!pattern)
+        return [];
+    for (const file of files) {
+        if (!file.text)
+            continue;
+        for (const match of file.text.matchAll(pattern)) {
+            hints.add(match[0]);
+        }
+    }
+    return [...hints].sort();
+}
+function frameworkIdsForFile(file) {
+    return FRAMEWORK_CATALOG
+        .filter((candidate) => file.text && candidate.patterns.some((pattern) => pattern.test(file.text ?? '')))
+        .map((candidate) => candidate.id);
+}
+function providerIdsForFile(file) {
+    return PROVIDER_CATALOG
+        .filter((candidate) => file.text && candidate.patterns.some((pattern) => pattern.test(file.text ?? '')))
+        .map((candidate) => candidate.id);
+}
+function linkFrameworksAndProviders(graph) {
+    for (const agent of graph.runtimeAgents) {
+        const agentPaths = new Set([
+            agent.root,
+            ...agent.evidence.map((item) => item.path),
+            ...graph.artifacts
+                .filter((artifact) => agent.entrypointIds.includes(artifact.id) && artifact.sourcePath)
+                .map((artifact) => artifact.sourcePath),
+        ]);
+        for (const framework of graph.agentFrameworks) {
+            if (detectionAppliesToAgent(framework.evidence, agent, agentPaths)) {
+                agent.frameworkIds = unique([...agent.frameworkIds, framework.id]).sort();
+                framework.runtimeAgentIds = unique([...framework.runtimeAgentIds, agent.id]).sort();
+            }
+        }
+        for (const provider of graph.modelProviders) {
+            if (detectionAppliesToAgent(provider.evidence, agent, agentPaths)) {
+                agent.modelProviderIds = unique([...agent.modelProviderIds, provider.id]).sort();
+                provider.runtimeAgentIds = unique([...provider.runtimeAgentIds, agent.id]).sort();
+            }
+        }
+    }
+}
+function detectionAppliesToAgent(evidence, agent, agentPaths) {
+    return evidence.some((item) => item.path === 'package.json' ||
+        item.path === 'pyproject.toml' ||
+        agentPaths.has(item.path) ||
+        item.path.startsWith(`${agent.root}/`));
+}
+function finalizeGraph(graph) {
+    const artifactMap = new Map(graph.artifacts.map((artifact) => [artifact.id, artifact]));
+    const channelMap = new Map(graph.channelAdapters.map((channel) => [channel.id, channel]));
+    const identityMap = new Map(graph.identityNamespaces.map((identity) => [identity.id, identity]));
+    const deploymentMap = new Map(graph.deployments.map((deployment) => [deployment.id, deployment]));
+    for (const agent of graph.runtimeAgents) {
+        for (const entrypointId of agent.entrypointIds) {
+            if (!artifactMap.has(entrypointId)) {
+                const sourcePath = agent.evidence[0]?.path ?? agent.root;
+                const entrypoint = {
+                    id: entrypointId,
+                    type: 'entrypoint',
+                    name: `${agent.name} Entrypoint`,
+                    scope: 'agent',
+                    sourcePath,
+                    ownedByAgentId: agent.id,
+                    usedByAgentIds: [agent.id],
+                    confidence: Math.min(0.82, agent.confidence),
+                    evidence: agent.evidence,
+                };
+                upsertArtifact(graph, entrypoint);
+                artifactMap.set(entrypointId, entrypoint);
+            }
+            graph.relationships.push({
+                type: 'owns_artifact',
+                from: agent.id,
+                to: entrypointId,
+                artifactId: entrypointId,
+                evidence: agent.evidence,
+            });
+        }
+        for (const channelId of agent.channelAdapterIds) {
+            if (!channelMap.has(channelId)) {
+                upsertChannel(graph, {
+                    id: channelId,
+                    name: titleFromId(channelId),
+                    kind: channelId.replace(/^channel_/, ''),
+                    confidence: 0.55,
+                    evidence: agent.evidence,
+                });
+            }
+            graph.relationships.push({
+                type: 'invoked_by_channel',
+                from: agent.id,
+                to: channelId,
+                evidence: agent.evidence,
+            });
+        }
+        for (const artifactId of agent.artifactIds) {
+            if (!artifactMap.has(artifactId)) {
+                const artifact = {
+                    id: artifactId,
+                    type: artifactTypeFromId(artifactId),
+                    name: titleFromId(artifactId),
+                    scope: 'agent',
+                    usedByAgentIds: [agent.id],
+                    confidence: 0.45,
+                    evidence: agent.evidence,
+                };
+                upsertArtifact(graph, artifact);
+                artifactMap.set(artifactId, artifact);
+            }
+            const artifact = artifactMap.get(artifactId);
+            if (artifact && !artifact.usedByAgentIds.includes(agent.id)) {
+                artifact.usedByAgentIds.push(agent.id);
+            }
+            graph.relationships.push({
+                type: 'uses_artifact',
+                from: agent.id,
+                to: artifactId,
+                artifactId,
+                evidence: artifact?.evidence ?? agent.evidence,
+            });
+        }
+        for (const identityId of agent.identityNamespaceIds) {
+            if (!identityMap.has(identityId)) {
+                upsertIdentity(graph, {
+                    id: identityId,
+                    name: titleFromId(identityId),
+                    kind: identityId.replace(/^identity_/, ''),
+                    confidence: 0.5,
+                    evidence: agent.evidence,
+                });
+            }
+        }
+        for (const deploymentId of agent.deploymentIds) {
+            if (!deploymentMap.has(deploymentId)) {
+                upsertDeployment(graph, {
+                    id: deploymentId,
+                    name: titleFromId(deploymentId),
+                    confidence: 0.5,
+                    evidence: agent.evidence,
+                });
+            }
+            graph.relationships.push({
+                type: 'deployed_as',
+                from: agent.id,
+                to: deploymentId,
+                evidence: agent.evidence,
+            });
+        }
+    }
+    const familyMap = new Map(graph.agentFamilies.map((family) => [family.id, family]));
+    for (const agent of graph.runtimeAgents) {
+        if (!agent.familyId)
+            continue;
+        const family = familyMap.get(agent.familyId);
+        if (family && !family.runtimeAgentIds.includes(agent.id)) {
+            family.runtimeAgentIds.push(agent.id);
+        }
+    }
+    for (const family of graph.agentFamilies) {
+        const shared = graph.artifacts
+            .filter((artifact) => artifact.usedByAgentIds.filter((agentId) => family.runtimeAgentIds.includes(agentId)).length > 1)
+            .map((artifact) => artifact.id);
+        family.sharedArtifactIds = unique([...family.sharedArtifactIds, ...shared]);
+    }
+    for (const artifact of graph.artifacts) {
+        artifact.usedByAgentIds = unique(artifact.usedByAgentIds).sort();
+        if (artifact.usedByAgentIds.length > 1) {
+            artifact.scope = 'shared';
+            for (const from of artifact.usedByAgentIds) {
+                for (const to of artifact.usedByAgentIds) {
+                    if (from === to)
+                        continue;
+                    graph.relationships.push({
+                        type: 'shares_artifact_with',
+                        from,
+                        to,
+                        artifactId: artifact.id,
+                        evidence: artifact.evidence,
+                    });
+                }
+            }
+        }
+    }
+    for (const identity of graph.identityNamespaces) {
+        if (identity.canonicalId && identity.canonicalId !== identity.id) {
+            graph.relationships.push({
+                type: 'resolves_identity_to',
+                from: identity.id,
+                to: identity.canonicalId,
+                evidence: identity.evidence,
+            });
+        }
+    }
+    if (graph.runtimeAgents.length > 1 && graph.agentFamilies.length === 0) {
+        graph.unknowns.push({
+            id: 'unknown_agent_grouping',
+            question: 'Multiple runtime agents were detected. Confirm whether any should be grouped into an agent family.',
+            candidateIds: graph.runtimeAgents.map((agent) => agent.id),
+            evidence: graph.runtimeAgents.flatMap((agent) => agent.evidence).slice(0, 5),
+        });
+    }
+    graph.agentFamilies.sort((a, b) => a.id.localeCompare(b.id));
+    graph.runtimeAgents.sort((a, b) => a.id.localeCompare(b.id));
+    graph.channelAdapters.sort((a, b) => a.id.localeCompare(b.id));
+    graph.artifacts.sort((a, b) => a.id.localeCompare(b.id));
+    graph.identityNamespaces.sort((a, b) => a.id.localeCompare(b.id));
+    graph.agentFrameworks.sort((a, b) => a.id.localeCompare(b.id));
+    graph.modelProviders.sort((a, b) => a.id.localeCompare(b.id));
+    graph.deployments.sort((a, b) => a.id.localeCompare(b.id));
+    graph.relationships = dedupeRelationships(graph.relationships);
+}
+function upsertRuntimeAgent(graph, next) {
+    const existing = graph.runtimeAgents.find((agent) => agent.id === next.id);
+    if (!existing) {
+        graph.runtimeAgents.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+    existing.entrypointIds = unique([...existing.entrypointIds, ...next.entrypointIds]);
+    existing.channelAdapterIds = unique([...existing.channelAdapterIds, ...next.channelAdapterIds]);
+    existing.artifactIds = unique([...existing.artifactIds, ...next.artifactIds]);
+    existing.identityNamespaceIds = unique([...existing.identityNamespaceIds, ...next.identityNamespaceIds]);
+    existing.deploymentIds = unique([...existing.deploymentIds, ...next.deploymentIds]);
+    existing.frameworkIds = unique([...existing.frameworkIds, ...next.frameworkIds]);
+    existing.modelProviderIds = unique([...existing.modelProviderIds, ...next.modelProviderIds]);
+    existing.familyId = existing.familyId ?? next.familyId;
+    existing.purpose = existing.purpose ?? next.purpose;
+}
+function upsertAgentFamily(graph, next) {
+    const existing = graph.agentFamilies.find((family) => family.id === next.id);
+    if (!existing) {
+        graph.agentFamilies.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+    existing.runtimeAgentIds = unique([...existing.runtimeAgentIds, ...next.runtimeAgentIds]);
+    existing.sharedArtifactIds = unique([...existing.sharedArtifactIds, ...next.sharedArtifactIds]);
+}
+function upsertChannel(graph, next) {
+    const existing = graph.channelAdapters.find((channel) => channel.id === next.id);
+    if (!existing) {
+        graph.channelAdapters.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+}
+function upsertArtifact(graph, next) {
+    const existing = graph.artifacts.find((artifact) => artifact.id === next.id);
+    if (!existing) {
+        graph.artifacts.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+    existing.usedByAgentIds = unique([...existing.usedByAgentIds, ...next.usedByAgentIds]);
+    existing.ownedByAgentId = existing.ownedByAgentId ?? next.ownedByAgentId;
+    existing.contentHash = existing.contentHash ?? next.contentHash;
+    existing.sourcePath = existing.sourcePath ?? next.sourcePath;
+    if (existing.scope !== 'shared')
+        existing.scope = next.scope;
+}
+function upsertIdentity(graph, next) {
+    const existing = graph.identityNamespaces.find((identity) => identity.id === next.id);
+    if (!existing) {
+        graph.identityNamespaces.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+    existing.canonicalId = existing.canonicalId ?? next.canonicalId;
+}
+function upsertEnvironment(graph, next) {
+    const existing = graph.environments.find((env) => env.id === next.id);
+    if (!existing) {
+        graph.environments.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+}
+function upsertDeployment(graph, next) {
+    const existing = graph.deployments.find((deployment) => deployment.id === next.id);
+    if (!existing) {
+        graph.deployments.push(next);
+        return;
+    }
+    existing.evidence = mergeEvidence(existing.evidence, next.evidence);
+    existing.confidence = Math.max(existing.confidence, next.confidence);
+    existing.environmentId = existing.environmentId ?? next.environmentId;
+}
+function contentHashForAnnotatedSource(sourcePath, annotation) {
+    const explicitSourcePath = normalizePath(sourcePath) !== normalizePath(annotation.evidence.path);
+    const candidates = explicitSourcePath ? [
+        resolve(annotation.rootDir, sourcePath),
+        resolve(dirname(annotation.sourceAbsPath), sourcePath),
+    ] : [
+        resolve(annotation.rootDir, sourcePath),
+        resolve(dirname(annotation.sourceAbsPath), sourcePath),
+        annotation.sourceAbsPath,
+    ];
+    const seen = new Set();
+    for (const candidate of candidates) {
+        if (seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        const text = readSmallTextFileForHash(candidate, annotation.rootDir);
+        if (text !== undefined)
+            return hashText(text);
+    }
+    return undefined;
+}
+function readSmallTextFileForHash(absPath, rootDir) {
+    if (!existsSync(absPath))
+        return undefined;
+    const rel = normalizePath(relative(rootDir, absPath));
+    if (isSecretishPath(rel))
+        return undefined;
+    let stat;
+    try {
+        stat = lstatSync(absPath);
+    }
+    catch {
+        return undefined;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_SCANNED_FILE_BYTES) {
+        return undefined;
+    }
+    if (!isTextFile(rel))
+        return undefined;
+    try {
+        return readFileSync(absPath, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function dedupeRelationships(relationships) {
+    const seen = new Set();
+    const result = [];
+    for (const relationship of relationships) {
+        const key = [
+            relationship.type,
+            relationship.from,
+            relationship.to,
+            relationship.artifactId ?? '',
+        ].join('\0');
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(relationship);
+    }
+    return result.sort((a, b) => `${a.type}:${a.from}:${a.to}:${a.artifactId ?? ''}`.localeCompare(`${b.type}:${b.from}:${b.to}:${b.artifactId ?? ''}`));
+}
+function mergeEvidence(left, right) {
+    const seen = new Set();
+    const result = [];
+    for (const item of [...left, ...right]) {
+        const key = `${item.path}\0${item.reason}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(item);
+    }
+    return result;
+}
+function artifactType(value) {
+    if (value === 'entrypoint' ||
+        value === 'prompt' ||
+        value === 'tool' ||
+        value === 'skill' ||
+        value === 'eval' ||
+        value === 'retrieval_index' ||
+        value === 'memory' ||
+        value === 'guardrail' ||
+        value === 'model_config') {
+        return value;
+    }
+    return 'unknown';
+}
+function artifactTypeFromId(id) {
+    if (id.startsWith('prompt_'))
+        return 'prompt';
+    if (id.startsWith('tool_'))
+        return 'tool';
+    if (id.startsWith('skill_'))
+        return 'skill';
+    if (id.startsWith('eval_'))
+        return 'eval';
+    if (id.startsWith('entry_'))
+        return 'entrypoint';
+    if (id.startsWith('memory_'))
+        return 'memory';
+    if (id.startsWith('guardrail_'))
+        return 'guardrail';
+    if (id.startsWith('model_config_'))
+        return 'model_config';
+    return 'unknown';
+}
+function scopeValue(value) {
+    if (value === 'shared' || value === 'global' || value === 'agent')
+        return value;
+    return 'agent';
+}
+function numberValue(value, fallback) {
+    if (!value)
+        return fallback;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? Math.max(0, Math.min(1, parsed)) : fallback;
+}
+function first(values) {
+    return values?.[0];
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}
+function stableId(prefix, raw) {
+    const slug = raw
+        .toLowerCase()
+        .replace(/\.[^.]+$/g, '')
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .replace(/_+/g, '_')
+        .slice(0, 72);
+    return `${prefix}_${slug || hashText(raw).slice(0, 10)}`;
+}
+function titleFromId(id) {
+    return id
+        .replace(/^(agent|family|channel|prompt|tool|skill|eval|identity|deploy|entry|env)_/, '')
+        .split(/[_/.-]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ') || id;
+}
+function promptNameFromPath(path) {
+    return titleFromId(basename(path).replace(/\.(prompt\.)?(md|json|ya?ml)$/i, ''));
+}
+function normalizePath(path) {
+    return path.split(sep).join('/');
+}
+function hashText(text) {
+    return createHash('sha256').update(text).digest('hex');
+}
+//# sourceMappingURL=harness.js.map