@telora/daemon 0.21.12 → 0.21.81

package/dist/sensor-sweep.d.ts

@@ -1,194 +0,0 @@
-/**
- * Deterministic whole-repo sensor sweep -- the DC baseline for artifact health.
- *
- * Peer of the other daemon loop ticks (drift-eval, verification, merge-back).
- * Each tick walks every configured product's repo and, when the repo has drifted
- * since the last snapshot, mines a deterministic snapshot into the code_metrics
- * time series:
- *   - git churn + hotspot mass (change frequency x a language-agnostic size /
- *     indentation-complexity proxy over the changed set);
- *   - lint-gate ratchet exception counts harvested from scripts/lint-config.json;
- *   - dependency freshness derived from the package manifests;
- *   - intent-aligned churn: the fraction of window churn whose paths fall inside
- *     the footprint of active foci/deliveries (the paths their focus branches
- *     touch) vs outside any declared intent -- the Telora-native differential
- *     metric at the artifact layer (activity without intent reduction is noise).
- *
- * Purely deterministic: git + filesystem reads only, NO LLM and NO network
- * beyond the local repo. Burn is drift-proportional: a product whose repo HEAD
- * and manifest hash are unchanged since its last snapshot is skipped -- the
- * sweep sees cold-code rot and environment drift that activity-gated sampling
- * cannot, without re-mining an unchanged tree.
- *
- * All side effects (git, fs, the code_metrics query wrappers, the clock) are
- * injected via `Deps` so the miners and the drift-skip logic are unit-testable
- * without a real repo. Mirrors the drift-eval-loop.ts dependency-injection
- * pattern.
- *
- * MINING WINDOW IS TIME-BOUNDED, NOT COUNT-BOUNDED. The churn/hotspot window is
- * a fixed real-time span (`DEFAULT_WINDOW_DAYS`), not a fixed commit count. A
- * count-bounded window (e.g. "last 500 commits") makes consecutive snapshots
- * cover different lengths of real time, so cross-snapshot trends partly measure
- * commit velocity rather than code health -- a busy month and a quiet quarter
- * both look like "500 commits." Anchoring the window to calendar time makes
- * consecutive snapshots cover comparable spans, so a rising/falling trend
- * reflects the health of the code (churn, hotspot mass) independent of how fast
- * the team happened to be committing. A large secondary commit-count SAFETY CAP
- * (`COMMIT_SAFETY_CAP`) bounds the worst case so an extremely busy repo cannot
- * blow up the window; it is a defensive backstop, not the primary bound.
- *
- * @module sensor-sweep
- */
-import type { CodeMetricsSnapshotInput, LatestCodeMetrics } from './queries/code-metrics.js';
-import type { DaemonConfig } from './types.js';
-/** Per-file churn accumulated over the mining window. */
-export interface FileChurn {
-    changeCount: number;
-    linesChanged: number;
-    lastCommitMs: number;
-}
-/**
- * Parse `git log --since=<span> --numstat --format=COMMIT:%H %aI` output into
- * per-file churn. Pure: no git process. Binary numstat rows (`-\t-`) are
- * skipped. The `--format` output shape is identical regardless of whether the
- * window was count- or time-bounded, so this parser is unchanged.
- */
-export declare function parseNumstatPerFile(output: string): Map<string, FileChurn>;
-/**
- * Language-agnostic complexity proxy for a file body: line count plus the sum of
- * per-line indentation depth (leading whitespace, tabs counted as one level).
- * Deeper, longer files score higher without any per-language AST tooling.
- */
-export declare function complexityProxy(content: string): number;
-/** Map a repo-relative path to an area = its first `depth` path segments. */
-export declare function areaOf(filePath: string, depth?: number): string;
-/** One area's aggregated metrics (gradient-tier detail). */
-export interface AreaMetric {
-    area: string;
-    churn: number;
-    hotspotMass: number;
-    fileCount: number;
-    ageDays: number;
-}
-/**
- * Aggregate per-file churn + complexity into per-area metrics and repo totals.
- * `complexityFor(file)` returns the size/complexity proxy for a changed file
- * (injected so tests need no fs); a missing file falls back to its linesChanged.
- */
-export declare function aggregateAreas(perFile: Map<string, FileChurn>, complexityFor: (file: string) => number | null, nowMs: number, depth?: number): {
-    areas: AreaMetric[];
-    totalChurn: number;
-    totalHotspotMass: number;
-};
-/** Intent-aligned churn: how much of the window churn served declared intent. */
-export interface IntentAlignedChurn {
-    /** Lines of window churn on paths inside the active-intent footprint. */
-    alignedChurn: number;
-    /** Total lines changed in the window (all paths). */
-    totalChurn: number;
-    /**
-     * alignedChurn / totalChurn, bounded 0-1, or NULL when there was no churn.
-     * A zero-churn window is definitionally UNMEASURED for alignment (0/0 is
-     * undefined) -- it must read null, never a fake measured-0. A churn>0 window
-     * with nothing aligned is a GENUINE 0, not null.
-     */
-    alignedRatio: number | null;
-}
-/**
- * The Telora-native differential metric at the artifact layer: what FRACTION of
- * the window churn landed inside the footprint of active foci/deliveries
- * (`intentPaths`) versus outside any declared intent. Activity without intent
- * reduction is noise -- this makes that noise measurable.
- *
- * Pure over the injected per-file churn + the intent-path set: no git. A file is
- * "aligned" when its exact repo-relative path is in `intentPaths` (the union of
- * paths the active focus branches have changed). The ratio is bounded 0-1 and is
- * scale-free, so it is comparable across snapshots regardless of absolute churn.
- */
-export declare function computeIntentAlignedChurn(perFile: Map<string, FileChurn>, intentPaths: ReadonlySet<string>): IntentAlignedChurn;
-/**
- * Count lint-gate ratchet exceptions from a parsed scripts/lint-config.json.
- * Each top-level category (except `_comment`) is an array of allowlist entries;
- * a growing count is accumulating debt the ratchet is holding back.
- */
-export declare function countRatchets(lintConfig: unknown): {
-    total: number;
-    detail: Record<string, number>;
-};
-/** A dependency manifest's parsed content. */
-export interface Manifest {
-    path: string;
-    content: unknown;
-}
-/**
- * Derive dependency freshness from manifests alone (no registry / network).
- * `outdated` is a deterministic risk proxy: a dependency pinned to a pre-1.0
- * (0.x) major, or to an unbounded/floating range (`*`, `latest`, `x`), reads as
- * a freshness/stability risk. Also returns a stable manifest hash for the
- * drift-skip key.
- */
-export declare function analyzeManifests(manifests: Manifest[]): {
-    dependencyCount: number;
-    dependencyOutdated: number;
-    detail: Record<string, {
-        count: number;
-        outdated: number;
-    }>;
-    manifestHash: string;
-};
-/** Pre-1.0 major or unbounded/floating range => a deterministic freshness risk. */
-export declare function isOutdatedSpec(spec: string): boolean;
-/** FNV-1a 32-bit -- a small, dependency-free deterministic string hash. */
-export declare function fnv1a(input: string): string;
-export interface SensorSweepDeps {
-    /**
-     * Raw `git log --since=<windowDays>.days.ago -n<commitCap> --numstat
-     * --format=COMMIT:%H %aI` output for a repo. The window is TIME-bounded
-     * (`windowDays`) with `commitCap` as a defensive secondary cap.
-     */
-    gitNumstat: (repoPath: string, windowDays: number, commitCap: number) => string;
-    /** All tracked files (`git ls-files`) -- the cold baseline count + areas. */
-    listTrackedFiles: (repoPath: string) => string[];
-    /** Read a repo-relative file body, or null when unreadable (deleted/binary). */
-    readFile: (repoPath: string, relPath: string) => string | null;
-    /** Parsed scripts/lint-config.json, or null when absent. */
-    readLintConfig: (repoPath: string) => unknown | null;
-    /** Discovered + parsed package manifests. */
-    readManifests: (repoPath: string) => Manifest[];
-    /** Current HEAD sha, or null when git fails. */
-    resolveHeadSha: (repoPath: string) => string | null;
-    /**
-     * Repo-relative paths inside the footprint of active foci/deliveries -- the
-     * union of paths that unmerged focus branches (`agent/<role>/<slug>-<id>`) have
-     * changed vs the current mainline. The declared-intent half of the differential.
-     */
-    listIntentPaths: (repoPath: string) => string[];
-    getLatest: (productId: string) => Promise<LatestCodeMetrics | null>;
-    createSnapshot: (productId: string, input: CodeMetricsSnapshotInput) => Promise<{
-        id: string;
-    }>;
-    now: () => number;
-    /** Primary bound: real-time span (days) of the churn/hotspot mining window. */
-    windowDays: number;
-    /** Secondary defensive cap on the number of commits mined. */
-    commitCap: number;
-}
-export interface SensorSweepCounts {
-    productsScanned: number;
-    snapshotsWritten: number;
-    skippedUnchanged: number;
-    errors: number;
-}
-export declare function defaultSensorSweepDeps(): SensorSweepDeps;
-/**
- * Mine one repo into a snapshot input. Pure over the injected deps -- no global
- * git/fs. Returns null when HEAD cannot be resolved (an unusable repo).
- */
-export declare function mineRepoSnapshot(repoPath: string, deps: SensorSweepDeps): CodeMetricsSnapshotInput | null;
-/**
- * Run one sensor-sweep tick across every configured product. Drift-proportional:
- * a product whose repo HEAD + manifest hash match its last snapshot is skipped.
- * Per-product try/catch keeps one bad repo from aborting the sweep.
- */
-export declare function runSensorSweepTick(config: DaemonConfig, depOverrides?: Partial<SensorSweepDeps>): Promise<SensorSweepCounts>;
-//# sourceMappingURL=sensor-sweep.d.ts.map

package/dist/sensor-sweep.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sensor-sweep.d.ts","sourceRoot":"","sources":["../src/sensor-sweep.ts"],"names":[],"mappings":"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"}

package/dist/sensor-sweep.js

@@ -1,458 +0,0 @@
-/**
- * Deterministic whole-repo sensor sweep -- the DC baseline for artifact health.
- *
- * Peer of the other daemon loop ticks (drift-eval, verification, merge-back).
- * Each tick walks every configured product's repo and, when the repo has drifted
- * since the last snapshot, mines a deterministic snapshot into the code_metrics
- * time series:
- *   - git churn + hotspot mass (change frequency x a language-agnostic size /
- *     indentation-complexity proxy over the changed set);
- *   - lint-gate ratchet exception counts harvested from scripts/lint-config.json;
- *   - dependency freshness derived from the package manifests;
- *   - intent-aligned churn: the fraction of window churn whose paths fall inside
- *     the footprint of active foci/deliveries (the paths their focus branches
- *     touch) vs outside any declared intent -- the Telora-native differential
- *     metric at the artifact layer (activity without intent reduction is noise).
- *
- * Purely deterministic: git + filesystem reads only, NO LLM and NO network
- * beyond the local repo. Burn is drift-proportional: a product whose repo HEAD
- * and manifest hash are unchanged since its last snapshot is skipped -- the
- * sweep sees cold-code rot and environment drift that activity-gated sampling
- * cannot, without re-mining an unchanged tree.
- *
- * All side effects (git, fs, the code_metrics query wrappers, the clock) are
- * injected via `Deps` so the miners and the drift-skip logic are unit-testable
- * without a real repo. Mirrors the drift-eval-loop.ts dependency-injection
- * pattern.
- *
- * MINING WINDOW IS TIME-BOUNDED, NOT COUNT-BOUNDED. The churn/hotspot window is
- * a fixed real-time span (`DEFAULT_WINDOW_DAYS`), not a fixed commit count. A
- * count-bounded window (e.g. "last 500 commits") makes consecutive snapshots
- * cover different lengths of real time, so cross-snapshot trends partly measure
- * commit velocity rather than code health -- a busy month and a quiet quarter
- * both look like "500 commits." Anchoring the window to calendar time makes
- * consecutive snapshots cover comparable spans, so a rising/falling trend
- * reflects the health of the code (churn, hotspot mass) independent of how fast
- * the team happened to be committing. A large secondary commit-count SAFETY CAP
- * (`COMMIT_SAFETY_CAP`) bounds the worst case so an extremely busy repo cannot
- * blow up the window; it is a defensive backstop, not the primary bound.
- *
- * @module sensor-sweep
- */
-import { readFileSync, readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { runGitSync } from './git/index.js';
-import { configForProduct } from './config.js';
-import { getLatestCodeMetrics, createCodeMetricsSnapshot } from './queries/code-metrics.js';
-import { createLogger } from './log.js';
-const log = createLogger({ module: 'sensor-sweep' });
-/**
- * Real-time span (days) that defines the churn/hotspot mining window. This is
- * the PRIMARY bound: consecutive snapshots cover comparable calendar spans so
- * trends measure code health, not commit velocity. 90 days is one quarter --
- * long enough to capture a meaningful change-frequency signal, short enough to
- * stay responsive to recent activity.
- */
-const DEFAULT_WINDOW_DAYS = 90;
-/**
- * Secondary defensive bound on the number of commits mined. NOT the primary
- * window -- it only caps the worst case so an extremely busy repo (thousands of
- * commits inside the day window) cannot blow up parsing/memory. Set far above
- * any realistic 90-day commit count.
- */
-const COMMIT_SAFETY_CAP = 5000;
-const MS_PER_DAY = 86_400_000;
-/**
- * Parse `git log --since=<span> --numstat --format=COMMIT:%H %aI` output into
- * per-file churn. Pure: no git process. Binary numstat rows (`-\t-`) are
- * skipped. The `--format` output shape is identical regardless of whether the
- * window was count- or time-bounded, so this parser is unchanged.
- */
-export function parseNumstatPerFile(output) {
-    const perFile = new Map();
-    let commitMs = 0;
-    for (const rawLine of output.split('\n')) {
-        const line = rawLine.trimEnd();
-        if (!line)
-            continue;
-        if (line.startsWith('COMMIT:')) {
-            // "COMMIT:<sha> <iso8601>"
-            const rest = line.slice('COMMIT:'.length).trim();
-            const spaceIdx = rest.indexOf(' ');
-            const iso = spaceIdx >= 0 ? rest.slice(spaceIdx + 1).trim() : '';
-            const parsed = iso ? Date.parse(iso) : NaN;
-            commitMs = Number.isNaN(parsed) ? commitMs : parsed;
-            continue;
-        }
-        const parts = line.split('\t');
-        if (parts.length < 3)
-            continue;
-        const added = parts[0];
-        const removed = parts[1];
-        const file = parts[2];
-        if (!file)
-            continue;
-        if (added === '-' || removed === '-')
-            continue; // binary
-        const lines = (parseInt(added, 10) || 0) + (parseInt(removed, 10) || 0);
-        const existing = perFile.get(file);
-        if (existing) {
-            existing.changeCount += 1;
-            existing.linesChanged += lines;
-            if (commitMs > existing.lastCommitMs)
-                existing.lastCommitMs = commitMs;
-        }
-        else {
-            perFile.set(file, { changeCount: 1, linesChanged: lines, lastCommitMs: commitMs });
-        }
-    }
-    return perFile;
-}
-/**
- * Language-agnostic complexity proxy for a file body: line count plus the sum of
- * per-line indentation depth (leading whitespace, tabs counted as one level).
- * Deeper, longer files score higher without any per-language AST tooling.
- */
-export function complexityProxy(content) {
-    let score = 0;
-    for (const line of content.split('\n')) {
-        if (!line.trim())
-            continue;
-        score += 1; // one per non-blank line
-        const leading = line.length - line.trimStart().length;
-        // Normalize indentation: tabs and 2-space steps both count as ~1 level.
-        score += Math.floor(leading / 2);
-    }
-    return score;
-}
-/** Map a repo-relative path to an area = its first `depth` path segments. */
-export function areaOf(filePath, depth = 2) {
-    const segments = filePath.split('/').filter(Boolean);
-    if (segments.length <= 1)
-        return '(root)';
-    return segments.slice(0, depth).join('/');
-}
-/**
- * Aggregate per-file churn + complexity into per-area metrics and repo totals.
- * `complexityFor(file)` returns the size/complexity proxy for a changed file
- * (injected so tests need no fs); a missing file falls back to its linesChanged.
- */
-export function aggregateAreas(perFile, complexityFor, nowMs, depth = 2) {
-    const byArea = new Map();
-    let totalChurn = 0;
-    let totalHotspotMass = 0;
-    for (const [file, churn] of perFile) {
-        const complexity = complexityFor(file);
-        const sizeProxy = complexity == null ? churn.linesChanged : complexity;
-        const hotspot = churn.changeCount * sizeProxy;
-        totalChurn += churn.linesChanged;
-        totalHotspotMass += hotspot;
-        const area = areaOf(file, depth);
-        const bucket = byArea.get(area) ?? { churn: 0, hotspotMass: 0, files: new Set(), newestMs: 0 };
-        bucket.churn += churn.linesChanged;
-        bucket.hotspotMass += hotspot;
-        bucket.files.add(file);
-        if (churn.lastCommitMs > bucket.newestMs)
-            bucket.newestMs = churn.lastCommitMs;
-        byArea.set(area, bucket);
-    }
-    const areas = [...byArea.entries()]
-        .map(([area, b]) => ({
-        area,
-        churn: b.churn,
-        hotspotMass: b.hotspotMass,
-        fileCount: b.files.size,
-        ageDays: b.newestMs > 0 ? Math.max(0, Math.round((nowMs - b.newestMs) / MS_PER_DAY)) : 0,
-    }))
-        .sort((a, b) => b.hotspotMass - a.hotspotMass);
-    return { areas, totalChurn, totalHotspotMass };
-}
-/**
- * The Telora-native differential metric at the artifact layer: what FRACTION of
- * the window churn landed inside the footprint of active foci/deliveries
- * (`intentPaths`) versus outside any declared intent. Activity without intent
- * reduction is noise -- this makes that noise measurable.
- *
- * Pure over the injected per-file churn + the intent-path set: no git. A file is
- * "aligned" when its exact repo-relative path is in `intentPaths` (the union of
- * paths the active focus branches have changed). The ratio is bounded 0-1 and is
- * scale-free, so it is comparable across snapshots regardless of absolute churn.
- */
-export function computeIntentAlignedChurn(perFile, intentPaths) {
-    let alignedChurn = 0;
-    let totalChurn = 0;
-    for (const [file, churn] of perFile) {
-        totalChurn += churn.linesChanged;
-        if (intentPaths.has(file))
-            alignedChurn += churn.linesChanged;
-    }
-    // totalChurn === 0 -> the fraction is 0/0, undefined: unmeasured, persist null.
-    // totalChurn > 0 with alignedChurn 0 -> a genuine measurement (all churn landed
-    // outside declared intent), persist 0.
-    const alignedRatio = totalChurn > 0 ? alignedChurn / totalChurn : null;
-    return { alignedChurn, totalChurn, alignedRatio };
-}
-/**
- * Count lint-gate ratchet exceptions from a parsed scripts/lint-config.json.
- * Each top-level category (except `_comment`) is an array of allowlist entries;
- * a growing count is accumulating debt the ratchet is holding back.
- */
-export function countRatchets(lintConfig) {
-    const detail = {};
-    let total = 0;
-    if (lintConfig && typeof lintConfig === 'object') {
-        for (const [key, value] of Object.entries(lintConfig)) {
-            if (key.startsWith('_'))
-                continue;
-            if (Array.isArray(value)) {
-                detail[key] = value.length;
-                total += value.length;
-            }
-            else if (value && typeof value === 'object') {
-                // Nested { category: [...] } shapes contribute their array lengths.
-                for (const inner of Object.values(value)) {
-                    if (Array.isArray(inner))
-                        total += inner.length;
-                }
-                detail[key] = total;
-            }
-        }
-    }
-    return { total, detail };
-}
-/**
- * Derive dependency freshness from manifests alone (no registry / network).
- * `outdated` is a deterministic risk proxy: a dependency pinned to a pre-1.0
- * (0.x) major, or to an unbounded/floating range (`*`, `latest`, `x`), reads as
- * a freshness/stability risk. Also returns a stable manifest hash for the
- * drift-skip key.
- */
-export function analyzeManifests(manifests) {
-    const detail = {};
-    let dependencyCount = 0;
-    let dependencyOutdated = 0;
-    const hashParts = [];
-    const sorted = [...manifests].sort((a, b) => a.path.localeCompare(b.path));
-    for (const manifest of sorted) {
-        const content = manifest.content;
-        let count = 0;
-        let outdated = 0;
-        if (content && typeof content === 'object') {
-            const c = content;
-            for (const section of ['dependencies', 'devDependencies']) {
-                const deps = c[section];
-                if (deps && typeof deps === 'object' && !Array.isArray(deps)) {
-                    for (const [name, spec] of Object.entries(deps)) {
-                        const specStr = String(spec);
-                        count += 1;
-                        hashParts.push(`${manifest.path}:${name}@${specStr}`);
-                        if (isOutdatedSpec(specStr))
-                            outdated += 1;
-                    }
-                }
-            }
-        }
-        detail[manifest.path] = { count, outdated };
-        dependencyCount += count;
-        dependencyOutdated += outdated;
-    }
-    return { dependencyCount, dependencyOutdated, detail, manifestHash: fnv1a(hashParts.join('\n')) };
-}
-/** Pre-1.0 major or unbounded/floating range => a deterministic freshness risk. */
-export function isOutdatedSpec(spec) {
-    const s = spec.trim();
-    if (s === '*' || s === 'latest' || s === 'x' || s === '')
-        return true;
-    // Strip a single leading range operator, then test for a 0.x major.
-    const stripped = s.replace(/^[\^~>=<]+/, '');
-    return /^0\./.test(stripped);
-}
-/** FNV-1a 32-bit -- a small, dependency-free deterministic string hash. */
-export function fnv1a(input) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < input.length; i++) {
-        hash ^= input.charCodeAt(i);
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16).padStart(8, '0');
-}
-export function defaultSensorSweepDeps() {
-    return {
-        gitNumstat: (repoPath, windowDays, commitCap) => {
-            const result = runGitSync([
-                'log',
-                `--since=${windowDays}.days.ago`,
-                `-n${commitCap}`,
-                '--numstat',
-                '--format=COMMIT:%H %aI',
-            ], repoPath, { timeoutMs: 60_000 });
-            return result.success ? (result.output ?? '') : '';
-        },
-        listTrackedFiles: (repoPath) => {
-            const result = runGitSync(['ls-files'], repoPath, { timeoutMs: 30_000 });
-            if (!result.success)
-                return [];
-            return result.output.split('\n').map((l) => l.trim()).filter(Boolean);
-        },
-        readFile: (repoPath, relPath) => {
-            try {
-                return readFileSync(join(repoPath, relPath), 'utf8');
-            }
-            catch {
-                return null;
-            }
-        },
-        readLintConfig: (repoPath) => {
-            try {
-                return JSON.parse(readFileSync(join(repoPath, 'scripts', 'lint-config.json'), 'utf8'));
-            }
-            catch {
-                return null;
-            }
-        },
-        readManifests: (repoPath) => discoverManifests(repoPath),
-        resolveHeadSha: (repoPath) => {
-            const result = runGitSync(['rev-parse', 'HEAD'], repoPath, { timeoutMs: 15_000 });
-            return result.success ? result.output.trim() : null;
-        },
-        listIntentPaths: (repoPath) => {
-            // Enumerate active focus branches (agent/<role>/<slug>-<id>) and union the
-            // paths each has changed vs the current mainline (three-dot HEAD...branch,
-            // which diffs from their merge-base). Git-only + deterministic; a repo with
-            // no active focus branches yields an empty footprint (ratio -> 0).
-            const branchResult = runGitSync(['branch', '--list', 'agent/*', '--format=%(refname:short)'], repoPath, { timeoutMs: 15_000 });
-            if (!branchResult.success)
-                return [];
-            const branches = branchResult.output
-                .split('\n')
-                .map((l) => l.trim())
-                .filter(Boolean);
-            const paths = new Set();
-            for (const branch of branches) {
-                const diff = runGitSync(['diff', '--name-only', `HEAD...${branch}`], repoPath, { timeoutMs: 30_000 });
-                if (!diff.success)
-                    continue;
-                for (const p of diff.output.split('\n').map((l) => l.trim()).filter(Boolean)) {
-                    paths.add(p);
-                }
-            }
-            return [...paths];
-        },
-        getLatest: getLatestCodeMetrics,
-        createSnapshot: createCodeMetricsSnapshot,
-        now: () => Date.now(),
-        windowDays: DEFAULT_WINDOW_DAYS,
-        commitCap: COMMIT_SAFETY_CAP,
-    };
-}
-/** Discover package.json manifests at the repo root and one level into packages/ + mcp/. */
-function discoverManifests(repoPath) {
-    const found = [];
-    const candidates = ['package.json'];
-    for (const workspace of ['packages', 'mcp']) {
-        const dir = join(repoPath, workspace);
-        if (!existsSync(dir))
-            continue;
-        let entries = [];
-        try {
-            entries = readdirSync(dir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
-        }
-        catch {
-            entries = [];
-        }
-        for (const name of entries)
-            candidates.push(join(workspace, name, 'package.json'));
-    }
-    for (const rel of candidates) {
-        const abs = join(repoPath, rel);
-        if (!existsSync(abs))
-            continue;
-        try {
-            found.push({ path: rel.split(/[\\/]/).join('/'), content: JSON.parse(readFileSync(abs, 'utf8')) });
-        }
-        catch (err) {
-            // Skip unparseable manifests -- deterministic omission, not a crash.
-            log.debug('Skip unparseable manifests -- deterministic omission, not a crash', { error: String(err?.message ?? err) });
-        }
-    }
-    return found;
-}
-/**
- * Mine one repo into a snapshot input. Pure over the injected deps -- no global
- * git/fs. Returns null when HEAD cannot be resolved (an unusable repo).
- */
-export function mineRepoSnapshot(repoPath, deps) {
-    const repoHead = deps.resolveHeadSha(repoPath);
-    if (!repoHead)
-        return null;
-    const perFile = parseNumstatPerFile(deps.gitNumstat(repoPath, deps.windowDays, deps.commitCap));
-    const complexityCache = new Map();
-    const complexityFor = (file) => {
-        if (complexityCache.has(file))
-            return complexityCache.get(file) ?? null;
-        const body = deps.readFile(repoPath, file);
-        const value = body == null ? null : complexityProxy(body);
-        complexityCache.set(file, value);
-        return value;
-    };
-    const { areas, totalChurn, totalHotspotMass } = aggregateAreas(perFile, complexityFor, deps.now());
-    const ratchets = countRatchets(deps.readLintConfig(repoPath));
-    const manifests = analyzeManifests(deps.readManifests(repoPath));
-    const fileCount = deps.listTrackedFiles(repoPath).length;
-    const intentAligned = computeIntentAlignedChurn(perFile, new Set(deps.listIntentPaths(repoPath)));
-    return {
-        repoHead,
-        manifestHash: manifests.manifestHash,
-        hotspotMass: totalHotspotMass,
-        totalChurn,
-        fileCount,
-        ratchetCount: ratchets.total,
-        dependencyCount: manifests.dependencyCount,
-        dependencyOutdated: manifests.dependencyOutdated,
-        areas,
-        ratchetDetail: ratchets.detail,
-        dependencyDetail: manifests.detail,
-        intentAlignedChurn: intentAligned.alignedChurn,
-        intentAlignedRatio: intentAligned.alignedRatio,
-    };
-}
-/**
- * Run one sensor-sweep tick across every configured product. Drift-proportional:
- * a product whose repo HEAD + manifest hash match its last snapshot is skipped.
- * Per-product try/catch keeps one bad repo from aborting the sweep.
- */
-export async function runSensorSweepTick(config, depOverrides = {}) {
-    const deps = { ...defaultSensorSweepDeps(), ...depOverrides };
-    const counts = {
-        productsScanned: 0,
-        snapshotsWritten: 0,
-        skippedUnchanged: 0,
-        errors: 0,
-    };
-    for (const product of config.products) {
-        counts.productsScanned++;
-        try {
-            const pc = configForProduct(config, product);
-            const snapshot = mineRepoSnapshot(pc.repoPath, deps);
-            if (!snapshot) {
-                counts.errors++;
-                continue;
-            }
-            const latest = await deps.getLatest(product.id);
-            if (latest && latest.repoHead === snapshot.repoHead && latest.manifestHash === snapshot.manifestHash) {
-                // Nothing drifted since the last snapshot -- skip re-mining (DC baseline
-                // is unchanged; burn stays proportional to drift, not calendar time).
-                counts.skippedUnchanged++;
-                continue;
-            }
-            await deps.createSnapshot(product.id, snapshot);
-            counts.snapshotsWritten++;
-        }
-        catch (err) {
-            counts.errors++;
-            log.warn('product tick failed:', err.message);
-        }
-    }
-    return counts;
-}
-//# sourceMappingURL=sensor-sweep.js.map