openplanr 1.18.0 → 1.20.0

package/dist/services/operate/evidence.js

@@ -1,47 +1,3 @@
-import { lstat, mkdir, readFile, realpath, rename, stat, writeFile } from 'node:fs/promises';
-import path from 'node:path';
-import { loadConfig } from '../config-service.js';
-import { resolveApiKey } from '../credentials-service.js';
-import { canonicalDigest, canonicalize } from './canonical.js';
-import { OperatingEventStore } from './event-store.js';
-import { createEvidenceDiagnostic } from './evidence-diagnostics.js';
-import { readImportedEvidenceFile } from './evidence-import.js';
-import { assertOperatingArtifact } from './protocol.js';
-import { executeGitHubReadOnly, executeGitReadOnly, executeLinearReadOnlyQuery, executeRestReadOnlyJson, } from './read-only-providers.js';
-import { compareSensitivity, detectSecretMetadata, sanitizeEvidenceItem } from './redaction.js';
-import { OPERATE_PROTOCOL_VERSION, OPERATE_SCHEMA_VERSION, OperateError, } from './types.js';
-import { isPathInside, resolveOperatingPaths } from './workspace.js';
-const TEXT_EXTENSIONS = new Set([
-    '.c',
-    '.cc',
-    '.css',
-    '.csv',
-    '.go',
-    '.graphql',
-    '.h',
-    '.html',
-    '.java',
-    '.js',
-    '.json',
-    '.jsx',
-    '.kt',
-    '.md',
-    '.mjs',
-    '.py',
-    '.rb',
-    '.rs',
-    '.sh',
-    '.sql',
-    '.swift',
-    '.toml',
-    '.ts',
-    '.tsx',
-    '.yaml',
-    '.yml',
-]);
-function evidenceId(source, identity) {
-    return `EVD-${source}-${canonicalDigest(identity).slice('sha256:'.length, 19)}`;
-}
 export function evidenceFingerprintItems(items) {
     return items
         .map(({ id, digest, sensitivity }) => ({ id, digest, sensitivity }))
@@ -49,1037 +5,6 @@ export function evidenceFingerprintItems(items) {
         left.digest.localeCompare(right.digest) ||
         left.sensitivity.localeCompare(right.sensitivity));
 }
-function ageFreshness(collectedAt, now, ttlHours = 168) {
-    return now.getTime() - Date.parse(collectedAt) <= ttlHours * 60 * 60 * 1_000 ? 'fresh' : 'stale';
-}
-async function readRoots(projectRoot, localRoot) {
-    const candidates = [projectRoot, await realpath(projectRoot).catch(() => projectRoot)];
-    for (const candidate of [...new Set(candidates)]) {
-        try {
-            return JSON.parse(await readFile(resolveOperatingPaths(candidate, { localRoot }).roots, 'utf8'));
-        }
-        catch {
-            // Invocation paths can differ from their canonical real path on systems
-            // such as macOS where /var resolves through /private/var.
-        }
-    }
-    throw new OperateError('E_OPERATE_NOT_INITIALIZED', 'Machine-local workspace roots are missing; run `planr operate init` again.');
-}
-function descriptorById(workspace) {
-    return new Map([workspace.controlRepository, ...workspace.components].map((entry) => [
-        entry.componentId,
-        entry,
-    ]));
-}
-async function repositoryItems(roots, workspace, budgets, now, options) {
-    const descriptors = descriptorById(workspace);
-    const results = [];
-    let files = 0;
-    let bytes = 0;
-    let truncated = false;
-    for (const [componentId, root] of Object.entries(roots.roots).sort()) {
-        if (Date.now() >= options.deadline) {
-            truncated = true;
-            break;
-        }
-        const descriptor = descriptors.get(componentId);
-        if (!descriptor)
-            continue;
-        const canonicalRoot = await realpath(root);
-        const names = (await executeGitReadOnly(canonicalRoot, ['ls-files', '-z']))
-            .split('\0')
-            .filter(Boolean)
-            .filter((name) => TEXT_EXTENSIONS.has(path.extname(name).toLowerCase()))
-            .sort();
-        for (const relativePath of names) {
-            if (Date.now() >= options.deadline ||
-                files >= budgets.maxFiles ||
-                results.length >= budgets.maxItems) {
-                truncated = true;
-                break;
-            }
-            const isPlanr = relativePath.startsWith('.planr/');
-            if ((!options.includeRepository && !isPlanr) ||
-                (isPlanr && !options.includePlanr && !options.includeRepository)) {
-                continue;
-            }
-            const target = path.join(canonicalRoot, relativePath);
-            const directInfo = await lstat(target).catch(() => null);
-            if (!directInfo)
-                continue;
-            const resolvedTarget = await realpath(target).catch(() => null);
-            if (!resolvedTarget)
-                continue;
-            if (!isPathInside(canonicalRoot, resolvedTarget)) {
-                throw new OperateError('E_OPERATE_PATH_ESCAPE', `Tracked evidence path follows a symlink outside its repository: ${componentId}/${relativePath}.`);
-            }
-            if (directInfo.isSymbolicLink())
-                continue;
-            const info = await stat(resolvedTarget).catch(() => null);
-            if (!info?.isFile() || info.size > budgets.maxItemBytes)
-                continue;
-            if (bytes + info.size > budgets.maxBytes) {
-                truncated = true;
-                break;
-            }
-            const content = await readFile(resolvedTarget, 'utf8').catch(() => null);
-            if (content === null || content.includes('\0'))
-                continue;
-            files += 1;
-            bytes += Buffer.byteLength(content);
-            const collectedAt = now.toISOString();
-            const repository = {
-                componentId,
-                canonicalRemote: `https://${descriptor.canonicalRemote}`,
-                revision: descriptor.pinnedRevision,
-                configuredBranch: descriptor.configuredBranch,
-                dirtyFingerprint: descriptor.dirtyFingerprint,
-                relativePath,
-                digest: canonicalDigest(content),
-                freshness: ageFreshness(collectedAt, now),
-                sensitivity: 'internal',
-                collectedAt,
-            };
-            if (options.includeRepository && results.length < budgets.maxItems) {
-                results.push({
-                    id: evidenceId('repository', `${componentId}:${relativePath}:${repository.digest}`),
-                    source: 'repository',
-                    location: `${componentId}/${relativePath}`,
-                    content,
-                    collectedAt,
-                    observedFrom: null,
-                    observedTo: collectedAt,
-                    freshness: repository.freshness,
-                    sensitivity: repository.sensitivity,
-                    claimTypes: ['code', 'architecture'],
-                    quality: 'observed',
-                    coverage: 'partial',
-                    repository,
-                });
-            }
-            if (isPlanr && options.includePlanr && results.length < budgets.maxItems) {
-                const planrClaims = [
-                    'planning',
-                    ...(relativePath.includes('/stories/') || relativePath.includes('/specs/')
-                        ? ['user-journey']
-                        : []),
-                    ...(relativePath.includes('outcome') || relativePath.includes('provenance')
-                        ? ['outcome']
-                        : []),
-                    ...(relativePath.includes('/support') ? ['support', 'operations'] : []),
-                ];
-                results.push({
-                    id: evidenceId('planr', `${componentId}:${relativePath}:${repository.digest}`),
-                    source: 'planr',
-                    location: `${componentId}/${relativePath}`,
-                    content,
-                    collectedAt,
-                    observedFrom: null,
-                    observedTo: collectedAt,
-                    freshness: repository.freshness,
-                    sensitivity: repository.sensitivity,
-                    claimTypes: planrClaims,
-                    quality: 'verified',
-                    coverage: 'partial',
-                    repository,
-                });
-            }
-        }
-    }
-    return { items: results, truncated };
-}
-async function gitItems(roots, workspace, now, deadline) {
-    const descriptors = descriptorById(workspace);
-    const results = [];
-    for (const [componentId, root] of Object.entries(roots.roots).sort()) {
-        const remaining = deadline - Date.now();
-        if (remaining <= 0)
-            return { items: results, truncated: true };
-        const descriptor = descriptors.get(componentId);
-        if (!descriptor)
-            continue;
-        // An unborn Git branch has no history to cite. The workspace manifest uses
-        // Git's null OID for that state; do not manufacture a change-history item
-        // that could incorrectly satisfy an advisor readiness requirement.
-        if (/^0{40,64}$/u.test(descriptor.pinnedRevision))
-            continue;
-        const content = await executeGitReadOnly(root, [
-            'log',
-            '--since=30.days',
-            '--max-count=200',
-            '--date=iso-strict',
-            '--pretty=format:%H%x09%ad%x09%s',
-        ], { timeoutMs: remaining });
-        const collectedAt = now.toISOString();
-        results.push({
-            id: evidenceId('git', `${componentId}:${descriptor.pinnedRevision}:${content}`),
-            source: 'git',
-            location: `${componentId}/history`,
-            content,
-            collectedAt,
-            observedFrom: new Date(now.getTime() - 30 * 24 * 60 * 60 * 1_000).toISOString(),
-            observedTo: collectedAt,
-            freshness: 'fresh',
-            sensitivity: 'internal',
-            claimTypes: ['change-history'],
-            quality: 'verified',
-            coverage: 'partial',
-            repository: {
-                componentId,
-                canonicalRemote: `https://${descriptor.canonicalRemote}`,
-                revision: descriptor.pinnedRevision,
-                configuredBranch: descriptor.configuredBranch,
-                dirtyFingerprint: descriptor.dirtyFingerprint,
-                relativePath: '.git',
-                digest: canonicalDigest(content),
-                freshness: 'fresh',
-                sensitivity: 'internal',
-                collectedAt,
-            },
-        });
-    }
-    return { items: results, truncated: false };
-}
-function boundedRecordsContent(key, records, maxBytes) {
-    const selected = [...records];
-    let content = canonicalize({ [key]: selected });
-    while (selected.length > 0 && Buffer.byteLength(content) > maxBytes) {
-        selected.pop();
-        content = canonicalize({ [key]: selected });
-    }
-    if (Buffer.byteLength(content) > maxBytes) {
-        throw new OperateError('E_OPERATE_EVIDENCE_REJECTED', `${key} evidence cannot fit inside the configured item limit.`);
-    }
-    return {
-        content,
-        records: selected.length,
-        truncated: selected.length < records.length,
-    };
-}
-function githubIdentity(canonicalRemote) {
-    let url;
-    try {
-        url = new URL(canonicalRemote.includes('://') ? canonicalRemote : `https://${canonicalRemote}`);
-    }
-    catch {
-        return null;
-    }
-    if (url.protocol !== 'https:' ||
-        url.hostname.toLowerCase() !== 'github.com' ||
-        url.username ||
-        url.password ||
-        (url.port && url.port !== '443')) {
-        return null;
-    }
-    const segments = url.pathname
-        .replace(/\.git$/i, '')
-        .split('/')
-        .filter(Boolean);
-    if (segments.length !== 2 || segments.some((segment) => !/^[A-Za-z0-9_.-]+$/.test(segment))) {
-        return null;
-    }
-    return { owner: segments[0], repository: segments[1] };
-}
-async function githubPages(input) {
-    const results = [];
-    const pageSize = Math.min(100, Math.max(1, input.maxRecords));
-    const pageLimit = Math.min(5, Math.ceil(input.maxRecords / pageSize));
-    if (input.maxBytes < 1_024 || pageLimit < 1)
-        return results;
-    const perPageBytes = Math.max(1_024, Math.floor(input.maxBytes / pageLimit));
-    for (let page = 1; page <= pageLimit && results.length < input.maxRecords; page += 1) {
-        const remaining = input.deadline - Date.now();
-        if (remaining <= 0)
-            break;
-        const endpoint = new URL(input.endpoint);
-        endpoint.searchParams.set('per_page', String(pageSize));
-        endpoint.searchParams.set('page', String(page));
-        const response = await executeRestReadOnlyJson(endpoint, {
-            method: 'GET',
-            allowedHosts: ['api.github.com'],
-            timeoutMs: remaining,
-            maxBytes: Math.min(perPageBytes, 5 * 1024 * 1024),
-            fetchImpl: input.fetchImpl,
-            headers: {
-                accept: 'application/vnd.github+json',
-                authorization: `Bearer ${input.token}`,
-                'x-github-api-version': '2022-11-28',
-            },
-        });
-        const pageRecords = input.select(response);
-        const rawPageRecords = Array.isArray(response)
-            ? response.length
-            : response &&
-                typeof response === 'object' &&
-                Array.isArray(response.check_runs)
-                ? response.check_runs.length
-                : pageRecords.length;
-        results.push(...pageRecords.slice(0, input.maxRecords - results.length));
-        if (rawPageRecords < pageSize)
-            break;
-    }
-    return results;
-}
-export async function collectGitHubEvidence(input) {
-    const token = input.token?.trim() ||
-        process.env.GH_TOKEN?.trim() ||
-        process.env.GITHUB_TOKEN?.trim() ||
-        (await executeGitHubReadOnly(input.projectRoot, ['auth', 'token', '--hostname', 'github.com'], { allowedHosts: ['github.com'], timeoutMs: input.deadline - Date.now() })).trim();
-    if (!token) {
-        throw new OperateError('E_OPERATE_EVIDENCE_REJECTED', 'GitHub credentials are unavailable.');
-    }
-    const descriptors = [input.workspace.controlRepository, ...input.workspace.components];
-    const items = [];
-    let truncated = false;
-    let remainingBytes = input.budgets.maxBytes;
-    const maxRecords = Math.min(100, Math.max(1, Math.floor(input.budgets.maxItems / 4)));
-    const categoryResponseBytes = Math.max(1_024, Math.floor(input.budgets.maxBytes / 4));
-    for (const descriptor of descriptors) {
-        const identity = githubIdentity(descriptor.canonicalRemote);
-        if (!identity)
-            continue;
-        if (Date.now() >= input.deadline || items.length >= input.budgets.maxItems) {
-            truncated = true;
-            break;
-        }
-        const base = `https://api.github.com/repos/${encodeURIComponent(identity.owner)}/${encodeURIComponent(identity.repository)}`;
-        const categories = [
-            {
-                id: 'issues',
-                endpoint: `${base}/issues?state=all`,
-                claims: ['customer-signal', 'delivery'],
-                select: (value) => (Array.isArray(value) ? value : [])
-                    .filter((record) => Boolean(record) && typeof record === 'object' && !('pull_request' in record))
-                    .map((record) => ({
-                    number: record.number ?? null,
-                    title: record.title ?? null,
-                    state: record.state ?? null,
-                    createdAt: record.created_at ?? null,
-                    updatedAt: record.updated_at ?? null,
-                    labels: Array.isArray(record.labels)
-                        ? record.labels
-                            .map((label) => label && typeof label === 'object'
-                            ? label.name
-                            : label)
-                            .filter((label) => typeof label === 'string')
-                            .sort()
-                        : [],
-                })),
-            },
-            {
-                id: 'pull-requests',
-                endpoint: `${base}/pulls?state=all`,
-                claims: ['delivery', 'change-history'],
-                select: (value) => (Array.isArray(value) ? value : [])
-                    .filter((record) => Boolean(record) && typeof record === 'object')
-                    .map((record) => ({
-                    number: record.number ?? null,
-                    title: record.title ?? null,
-                    state: record.state ?? null,
-                    draft: record.draft ?? null,
-                    createdAt: record.created_at ?? null,
-                    updatedAt: record.updated_at ?? null,
-                    mergedAt: record.merged_at ?? null,
-                })),
-            },
-            {
-                id: 'releases',
-                endpoint: `${base}/releases`,
-                claims: ['delivery', 'change-history'],
-                select: (value) => (Array.isArray(value) ? value : [])
-                    .filter((record) => Boolean(record) && typeof record === 'object')
-                    .map((record) => ({
-                    id: record.id ?? null,
-                    tag: record.tag_name ?? null,
-                    name: record.name ?? null,
-                    draft: record.draft ?? null,
-                    prerelease: record.prerelease ?? null,
-                    createdAt: record.created_at ?? null,
-                    publishedAt: record.published_at ?? null,
-                })),
-            },
-            {
-                id: 'checks',
-                endpoint: `${base}/commits/${encodeURIComponent(descriptor.pinnedRevision)}/check-runs`,
-                claims: ['delivery', 'reliability'],
-                select: (value) => {
-                    if (!value || typeof value !== 'object')
-                        return [];
-                    const records = value.check_runs;
-                    return (Array.isArray(records) ? records : [])
-                        .filter((record) => Boolean(record) && typeof record === 'object')
-                        .map((record) => ({
-                        id: record.id ?? null,
-                        name: record.name ?? null,
-                        status: record.status ?? null,
-                        conclusion: record.conclusion ?? null,
-                        startedAt: record.started_at ?? null,
-                        completedAt: record.completed_at ?? null,
-                    }));
-                },
-            },
-        ];
-        for (const category of categories) {
-            if (Date.now() >= input.deadline ||
-                items.length >= input.budgets.maxItems ||
-                remainingBytes < 1_024) {
-                truncated = true;
-                break;
-            }
-            const records = (await githubPages({
-                token,
-                endpoint: category.endpoint,
-                deadline: input.deadline,
-                maxRecords,
-                maxBytes: Math.min(remainingBytes, categoryResponseBytes),
-                fetchImpl: input.fetchImpl,
-                select: category.select,
-            }));
-            const bounded = boundedRecordsContent(category.id, records, Math.min(input.budgets.maxItemBytes, remainingBytes));
-            truncated ||= bounded.truncated || records.length >= maxRecords;
-            remainingBytes -= Buffer.byteLength(bounded.content);
-            if (bounded.records === 0)
-                continue;
-            const collectedAt = input.now.toISOString();
-            items.push({
-                id: evidenceId('github', `${descriptor.componentId}:${category.id}:${bounded.content}`),
-                source: 'github',
-                location: `${descriptor.componentId}/${category.id}`,
-                content: bounded.content,
-                collectedAt,
-                observedFrom: null,
-                observedTo: collectedAt,
-                freshness: 'fresh',
-                sensitivity: 'confidential',
-                claimTypes: category.claims,
-                quality: 'observed',
-                coverage: bounded.truncated ? 'partial' : 'complete',
-            });
-        }
-    }
-    return { items, truncated };
-}
-async function linearConnectionPages(input) {
-    const records = [];
-    let after = null;
-    const pageSize = Math.min(100, Math.max(1, input.maxRecords));
-    const pageLimit = Math.min(5, Math.ceil(input.maxRecords / pageSize));
-    const perPageBytes = Math.max(1_024, Math.floor(input.maxBytes / Math.max(1, pageLimit)));
-    for (let page = 0; page < pageLimit && records.length < input.maxRecords; page += 1) {
-        const remaining = input.deadline - Date.now();
-        if (remaining <= 0)
-            break;
-        const data = await executeLinearReadOnlyQuery({
-            token: input.token,
-            query: input.query,
-            variables: {
-                ...input.variables,
-                first: pageSize,
-                after,
-            },
-            timeoutMs: remaining,
-            maxBytes: Math.min(perPageBytes, 5 * 1024 * 1024),
-            allowedHosts: ['api.linear.app'],
-            fetchImpl: input.fetchImpl,
-        });
-        const connection = data[input.connection];
-        const nodes = Array.isArray(connection?.nodes) ? connection.nodes : [];
-        records.push(...nodes.slice(0, input.maxRecords - records.length));
-        if (!connection?.pageInfo?.hasNextPage || !connection.pageInfo.endCursor)
-            break;
-        after = connection.pageInfo.endCursor;
-    }
-    return records;
-}
-export async function collectLinearEvidence(input) {
-    const token = input.token?.trim() || (await resolveApiKey('linear'))?.trim();
-    if (!token) {
-        throw new OperateError('E_OPERATE_EVIDENCE_REJECTED', 'Linear credentials are unavailable.');
-    }
-    const config = input.teamIds ? null : await loadConfig(input.projectRoot).catch(() => null);
-    const teamIds = [
-        ...new Set((input.teamIds ?? [
-            config?.linear?.teamId,
-            ...(config?.linear?.teams ?? []).map((team) => team.id),
-        ]).filter((value) => Boolean(value))),
-    ];
-    const maxRecords = Math.min(100, Math.max(1, Math.floor(input.budgets.maxItems / 3)));
-    const connectionBudget = Math.max(1_024, Math.floor(input.budgets.maxBytes / 3));
-    const teams = await linearConnectionPages({
-        token,
-        query: `query OperatingTeams($first: Int!, $after: String) {
-      teams(first: $first, after: $after) {
-        nodes { id key name }
-        pageInfo { hasNextPage endCursor }
-      }
-    }`,
-        connection: 'teams',
-        deadline: input.deadline,
-        maxRecords,
-        maxBytes: connectionBudget,
-        fetchImpl: input.fetchImpl,
-    });
-    const issues = await linearConnectionPages({
-        token,
-        query: teamIds.length > 0
-            ? `query OperatingIssues($first: Int!, $after: String, $teamIds: [ID!]) {
-            issues(first: $first, after: $after, filter: { team: { id: { in: $teamIds } } }) {
-              nodes {
-                id identifier title updatedAt priority
-                team { id key }
-                state { name }
-                labels { nodes { name } }
-              }
-              pageInfo { hasNextPage endCursor }
-            }
-          }`
-            : `query OperatingIssues($first: Int!, $after: String) {
-            issues(first: $first, after: $after) {
-              nodes {
-                id identifier title updatedAt priority
-                team { id key }
-                state { name }
-                labels { nodes { name } }
-              }
-              pageInfo { hasNextPage endCursor }
-            }
-          }`,
-        connection: 'issues',
-        variables: teamIds.length > 0 ? { teamIds } : {},
-        deadline: input.deadline,
-        maxRecords,
-        maxBytes: connectionBudget,
-        fetchImpl: input.fetchImpl,
-    });
-    const projects = await linearConnectionPages({
-        token,
-        query: `query OperatingProjects($first: Int!, $after: String) {
-      projects(first: $first, after: $after) {
-        nodes {
-          id name updatedAt
-          status { name }
-          teams { nodes { id key name } }
-        }
-        pageInfo { hasNextPage endCursor }
-      }
-    }`,
-        connection: 'projects',
-        deadline: input.deadline,
-        maxRecords,
-        maxBytes: connectionBudget,
-        fetchImpl: input.fetchImpl,
-    });
-    const selectedProjects = teamIds.length === 0
-        ? projects
-        : projects.filter((project) => (project.teams?.nodes ?? []).some((team) => team.id && teamIds.includes(team.id)));
-    const records = [
-        {
-            id: 'teams',
-            values: teams.map((team) => ({
-                id: team.id ?? null,
-                key: team.key ?? null,
-                name: team.name ?? null,
-            })),
-            claims: ['planning', 'operations'],
-        },
-        {
-            id: 'issues',
-            values: issues.map((issue) => ({
-                id: issue.id ?? null,
-                identifier: issue.identifier ?? null,
-                title: issue.title ?? null,
-                updatedAt: issue.updatedAt ?? null,
-                priority: issue.priority ?? null,
-                team: issue.team ? { id: issue.team.id ?? null, key: issue.team.key ?? null } : null,
-                state: issue.state?.name ?? null,
-                labels: (issue.labels?.nodes ?? [])
-                    .map((label) => label.name)
-                    .filter((label) => Boolean(label))
-                    .sort(),
-            })),
-            claims: ['customer-signal', 'delivery', 'planning'],
-        },
-        {
-            id: 'projects',
-            values: selectedProjects.map((project) => ({
-                id: project.id ?? null,
-                name: project.name ?? null,
-                updatedAt: project.updatedAt ?? null,
-                status: project.status?.name ?? null,
-                teams: (project.teams?.nodes ?? [])
-                    .map((team) => ({
-                    id: team.id ?? null,
-                    key: team.key ?? null,
-                    name: team.name ?? null,
-                }))
-                    .sort((left, right) => String(left.id).localeCompare(String(right.id))),
-            })),
-            claims: ['planning', 'operations', 'delivery'],
-        },
-    ];
-    const items = [];
-    let truncated = false;
-    let remainingBytes = input.budgets.maxBytes;
-    for (const record of records) {
-        if (remainingBytes < 1_024 || items.length >= input.budgets.maxItems) {
-            truncated = true;
-            break;
-        }
-        const bounded = boundedRecordsContent(record.id, record.values, Math.min(input.budgets.maxItemBytes, remainingBytes));
-        truncated ||= bounded.truncated || record.values.length >= maxRecords;
-        remainingBytes -= Buffer.byteLength(bounded.content);
-        if (bounded.records === 0)
-            continue;
-        const collectedAt = input.now.toISOString();
-        items.push({
-            id: evidenceId('linear', `${record.id}:${bounded.content}`),
-            source: 'linear',
-            location: record.id,
-            content: bounded.content,
-            collectedAt,
-            observedFrom: null,
-            observedTo: collectedAt,
-            freshness: 'fresh',
-            sensitivity: 'confidential',
-            claimTypes: record.claims,
-            quality: 'observed',
-            coverage: bounded.truncated ? 'partial' : 'complete',
-        });
-    }
-    return { items, truncated };
-}
-async function fileImportItems(projectRoot, roots, budgets, now, deadline, localRoot) {
-    const preferencesPath = path.join(resolveOperatingPaths(projectRoot, { localRoot }).localRoot, 'preferences.json');
-    const preferences = JSON.parse(await readFile(preferencesPath, 'utf8'));
-    const importPaths = Array.isArray(preferences.importPaths)
-        ? preferences.importPaths.filter((entry) => typeof entry === 'string')
-        : [];
-    if (importPaths.length === 0) {
-        throw new OperateError('E_OPERATE_CONFIG_INVALID', 'The file-import source has no configured evidence paths; rerun `planr operate init --evidence-file <path>`.');
-    }
-    const allowedRoots = Object.entries(roots.roots).map(([componentId, root]) => ({
-        componentId,
-        root,
-    }));
-    const items = [];
-    let bytes = 0;
-    let truncated = false;
-    for (const configuredPath of importPaths) {
-        if (Date.now() >= deadline ||
-            items.length >= budgets.maxItems ||
-            items.length >= budgets.maxFiles) {
-            truncated = true;
-            break;
-        }
-        const remainingBytes = budgets.maxBytes - bytes;
-        if (remainingBytes < 1) {
-            truncated = true;
-            break;
-        }
-        const imported = await readImportedEvidenceFile({
-            projectRoot,
-            configuredPath,
-            roots: allowedRoots,
-            maxBytes: Math.min(budgets.maxItemBytes, remainingBytes),
-        });
-        const commercialMetric = inferImportedCommercialMetric(imported.content, imported.format);
-        bytes += imported.byteCount;
-        const collectedAt = now.toISOString();
-        items.push({
-            id: evidenceId('file-import', `${imported.location}:${canonicalDigest(imported.content)}`),
-            source: 'file-import',
-            location: imported.location,
-            content: imported.content,
-            collectedAt,
-            observedFrom: null,
-            observedTo: collectedAt,
-            freshness: 'fresh',
-            sensitivity: 'internal',
-            claimTypes: [
-                'structured-data',
-                imported.format,
-                ...(commercialMetric.commercial ? ['commercial-metric'] : []),
-            ],
-            quality: 'self-reported',
-            coverage: 'complete',
-            ...(commercialMetric.metric ? { metric: commercialMetric.metric } : {}),
-        });
-    }
-    return { items, truncated };
-}
-const COMMERCIAL_METRIC_TERMS = /\b(?:activation|arr|arpu|cac|churn|conversion|customers?|gmv|ltv|margin|mrr|price|pricing|retention|revenue|sales|spend|subscriptions?|users?)\b/i;
-const NUMERIC_CLAIM = /(?:[$€£]\s*)?\b\d+(?:[.,]\d+)?\s*(?:%|percent|usd|eur|gbp|customers?|users?)?\b/i;
-function validIsoWindow(from, to) {
-    return (typeof from === 'string' &&
-        typeof to === 'string' &&
-        Number.isFinite(Date.parse(from)) &&
-        Number.isFinite(Date.parse(to)) &&
-        Date.parse(to) >= Date.parse(from));
-}
-function inferImportedCommercialMetric(content, format) {
-    const commercial = COMMERCIAL_METRIC_TERMS.test(content) && NUMERIC_CLAIM.test(content);
-    if (!commercial || format !== 'json')
-        return { commercial };
-    try {
-        const parsed = JSON.parse(content);
-        const candidate = parsed.metric && typeof parsed.metric === 'object'
-            ? parsed.metric
-            : null;
-        if (!candidate ||
-            typeof candidate.identity !== 'string' ||
-            !candidate.identity.trim() ||
-            typeof candidate.query !== 'string' ||
-            !candidate.query.trim() ||
-            !validIsoWindow(candidate.observedFrom, candidate.observedTo)) {
-            return { commercial };
-        }
-        return {
-            commercial,
-            metric: {
-                identity: candidate.identity.trim(),
-                query: candidate.query.trim(),
-                observedFrom: candidate.observedFrom,
-                observedTo: candidate.observedTo,
-            },
-        };
-    }
-    catch {
-        return { commercial };
-    }
-}
-function incrementalEvidencePath(input, key) {
-    return path.join(resolveOperatingPaths(input.projectRoot, { localRoot: input.localRoot }).evidence, 'incremental', `${key.slice('sha256:'.length)}.json`);
-}
-/**
- * FR4: the board's identity is the hash of its event-chain genesis event. The
- * incremental cache key incorporates it so a board re-inited at the same path —
- * whose workspace components (remote/branch) are unchanged and would otherwise
- * compute an identical key — never reuses a prior generation's baseline. Returns
- * '' when no committed chain exists yet or it cannot be read (the collection then
- * behaves exactly as before this change).
- */
-async function evidenceBoardIdentity(input) {
-    try {
-        const { events } = await new OperatingEventStore(input.projectRoot, {
-            localRoot: input.localRoot,
-        }).replay();
-        const genesis = events.find((event) => event.previousEventHash === null) ?? events[0];
-        return genesis?.eventHash ?? '';
-    }
-    catch {
-        return '';
-    }
-}
-async function readIncrementalEvidence(input, key) {
-    if (!input.incremental)
-        return null;
-    try {
-        const record = JSON.parse(await readFile(incrementalEvidencePath(input, key), 'utf8'));
-        if (record.implementation !== 'openplanr-operate-incremental-evidence' || record.key !== key) {
-            return null;
-        }
-        // FR4: honor the baseline's own already-written workspaceDigest. A record
-        // whose captured workspace no longer matches the current one is treated as
-        // no-baseline so the cycle recollects deep, rather than trusting a snapshot
-        // bound to a superseded workspace (for example, a prior board generation).
-        if (record.workspaceDigest !== input.workspace.workspaceDigest) {
-            return null;
-        }
-        await assertOperatingArtifact('operating-evidence', record.evidence);
-        return record;
-    }
-    catch {
-        return null;
-    }
-}
-async function writeIncrementalEvidence(input, key, evidence) {
-    if (!input.persistIncremental ||
-        input.providers.some((provider) => ['file-import', 'github', 'linear'].includes(provider))) {
-        return;
-    }
-    const target = incrementalEvidencePath(input, key);
-    await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
-    const temporary = `${target}.${process.pid}.tmp`;
-    const record = {
-        implementation: 'openplanr-operate-incremental-evidence',
-        key,
-        workspaceDigest: input.workspace.workspaceDigest,
-        evidence,
-    };
-    await writeFile(temporary, `${canonicalize(record)}\n`, { mode: 0o600 });
-    await rename(temporary, target);
-}
-function evidenceLocationIdentity(item) {
-    return `${item.source}\0${item.location}`;
-}
-function buildEvidenceDelta(input) {
-    const baselineItems = input.baseline?.items ?? [];
-    const baselineByLocation = new Map(baselineItems.map((item) => [evidenceLocationIdentity(item), item]));
-    const currentByLocation = new Map(input.current.map((item) => [evidenceLocationIdentity(item), item]));
-    const currentById = new Map(input.current.map((item) => [item.id, item]));
-    const baselineById = new Map(baselineItems.map((item) => [item.id, item]));
-    const changedEvidenceRefs = input.current
-        .filter((item) => {
-        const prior = baselineByLocation.get(evidenceLocationIdentity(item));
-        return (!prior ||
-            prior.digest !== item.digest ||
-            prior.sensitivity !== item.sensitivity ||
-            canonicalDigest(prior.metric ?? null) !== canonicalDigest(item.metric ?? null));
-    })
-        .map((item) => item.id)
-        .sort();
-    const removedEvidenceRefs = baselineItems
-        .filter((item) => !currentByLocation.has(evidenceLocationIdentity(item)))
-        .map((item) => item.id)
-        .sort();
-    const requiredEvidenceRefs = [
-        ...new Set(input.requiredEvidenceRefs.flatMap((reference) => {
-            const current = currentById.get(reference);
-            if (current)
-                return [current.id];
-            const prior = baselineById.get(reference);
-            if (!prior)
-                return [];
-            return [currentByLocation.get(evidenceLocationIdentity(prior))?.id ?? prior.id];
-        })),
-    ].sort();
-    return {
-        mode: input.incremental ? (input.baseline ? 'standard' : 'baseline') : 'deep',
-        baselineFingerprint: input.baseline?.fingerprint ?? null,
-        changedEvidenceRefs,
-        requiredEvidenceRefs,
-        selectedEvidenceRefs: [...new Set([...changedEvidenceRefs, ...requiredEvidenceRefs])].sort(),
-        removedEvidenceRefs,
-    };
-}
-export async function collectOperatingEvidence(input) {
-    const started = Date.now();
-    const now = input.now ?? new Date();
-    const deadline = started + input.budgets.maxDurationMs;
-    const incrementalKey = canonicalDigest({
-        boardIdentity: await evidenceBoardIdentity(input),
-        workspaceComponents: [input.workspace.controlRepository, ...input.workspace.components]
-            .map((component) => ({
-            componentId: component.componentId,
-            canonicalRemote: component.canonicalRemote,
-            configuredBranch: component.configuredBranch,
-        }))
-            .sort((left, right) => left.componentId.localeCompare(right.componentId)),
-        providers: [...new Set(input.providers)].sort(),
-        sensitivityCeiling: input.sensitivityCeiling,
-        budgets: input.budgets,
-    });
-    const baselineRecord = await readIncrementalEvidence(input, incrementalKey);
-    const roots = await readRoots(input.projectRoot, input.localRoot);
-    const raw = [];
-    const warnings = [];
-    let truncated = false;
-    if (input.providers.includes('repository') || input.providers.includes('planr')) {
-        const repository = await repositoryItems(roots, input.workspace, input.budgets, now, {
-            includeRepository: input.providers.includes('repository'),
-            includePlanr: input.providers.includes('planr'),
-            deadline,
-        });
-        raw.push(...repository.items);
-        truncated ||= repository.truncated;
-    }
-    if (input.providers.includes('git') && Date.now() < deadline) {
-        const git = await gitItems(roots, input.workspace, now, deadline);
-        raw.push(...git.items);
-        truncated ||= git.truncated;
-    }
-    if (input.providers.includes('github') && Date.now() < deadline) {
-        try {
-            const github = await collectGitHubEvidence({
-                projectRoot: input.projectRoot,
-                workspace: input.workspace,
-                now,
-                deadline,
-                budgets: input.budgets,
-                token: input.remote?.githubToken,
-                fetchImpl: input.remote?.fetchImpl,
-            });
-            raw.push(...github.items);
-            truncated ||= github.truncated;
-            if (github.items.length === 0) {
-                warnings.push('GitHub evidence found no supported repositories or records.');
-            }
-        }
-        catch {
-            warnings.push('GitHub evidence is unavailable or not authenticated.');
-        }
-    }
-    if (input.providers.includes('linear') && Date.now() < deadline) {
-        try {
-            const linear = await collectLinearEvidence({
-                projectRoot: input.projectRoot,
-                now,
-                deadline,
-                budgets: input.budgets,
-                token: input.remote?.linearToken,
-                fetchImpl: input.remote?.fetchImpl,
-            });
-            raw.push(...linear.items);
-            truncated ||= linear.truncated;
-            if (linear.items.length === 0) {
-                warnings.push('Linear evidence returned no configured teams, issues, or projects.');
-            }
-        }
-        catch {
-            warnings.push('Linear evidence is unavailable, not configured, or not authenticated.');
-        }
-    }
-    if (input.providers.includes('file-import') && Date.now() < deadline) {
-        const imported = await fileImportItems(input.projectRoot, roots, input.budgets, now, deadline, input.localRoot);
-        raw.push(...imported.items);
-        truncated ||= imported.truncated;
-    }
-    const rejected = raw.filter((item) => compareSensitivity(item.sensitivity, input.sensitivityCeiling) > 0);
-    if (rejected.length > 0) {
-        warnings.push(`${rejected.length} evidence item(s) exceeded the configured sensitivity ceiling.`);
-    }
-    const flattened = [];
-    for (const item of raw
-        .filter((candidate) => compareSensitivity(candidate.sensitivity, input.sensitivityCeiling) <= 0)
-        .slice(0, input.budgets.maxItems)) {
-        try {
-            flattened.push(sanitizeEvidenceItem(item));
-        }
-        catch (error) {
-            if (!(error instanceof OperateError) || error.code !== 'E_OPERATE_SECRET_DETECTED') {
-                throw error;
-            }
-            const details = error.details ?? {};
-            const fallback = detectSecretMetadata(item.content)[0];
-            const ruleId = typeof details.ruleId === 'string' ? details.ruleId : (fallback?.ruleId ?? 'unknown.v1');
-            const category = typeof details.category === 'string'
-                ? details.category
-                : (fallback?.category ?? 'structured-secret');
-            const diagnostic = await createEvidenceDiagnostic({
-                projectRoot: input.projectRoot,
-                item,
-                localRoot: input.localRoot,
-                detection: {
-                    ruleId,
-                    category,
-                    line: typeof details.line === 'number' && Number.isInteger(details.line)
-                        ? details.line
-                        : (fallback?.line ?? 1),
-                    hardBlock: typeof details.hardBlock === 'boolean'
-                        ? details.hardBlock
-                        : (fallback?.hardBlock ?? false),
-                },
-            });
-            if (diagnostic.classification?.status === 'false-positive') {
-                warnings.push(`Evidence candidate ${diagnostic.candidateId} was omitted under its exact false-positive classification.`);
-                continue;
-            }
-            // Quarantine the item instead of aborting the entire evidence snapshot.
-            // The immutable role-filtered packs never receive its bytes. Readiness
-            // evaluation below decides whether enough eligible evidence remains for
-            // each lens; an affected lens becomes not_evaluated with a governed gap
-            // rather than preventing unrelated lenses from producing useful work.
-            warnings.push([
-                `Evidence candidate ${diagnostic.candidateId} was quarantined`,
-                `(${diagnostic.category}); its value was not persisted or dispatched.`,
-                `Inspect with: planr operate evidence diagnose ${diagnostic.candidateId} --json`,
-            ].join(' '));
-        }
-    }
-    if (Date.now() >= deadline) {
-        truncated = true;
-        warnings.push('Evidence collection reached the configured duration budget.');
-    }
-    const sourceIds = [...new Set(input.providers)].sort();
-    const delta = buildEvidenceDelta({
-        incremental: Boolean(input.incremental),
-        current: flattened,
-        baseline: baselineRecord?.evidence ?? null,
-        requiredEvidenceRefs: input.requiredEvidenceRefs ?? [],
-    });
-    const baselineSources = new Map((baselineRecord?.evidence.sources ?? []).map((source) => [source.id, source]));
-    const sources = sourceIds.map((id) => {
-        const items = flattened.filter((item) => item.source === id);
-        const fingerprint = canonicalDigest(evidenceFingerprintItems(items));
-        const prior = baselineSources.get(id);
-        return {
-            id,
-            fingerprint,
-            status: items.length === 0
-                ? 'unavailable'
-                : delta.mode === 'standard' && prior?.fingerprint === fingerprint
-                    ? 'unchanged'
-                    : delta.mode === 'standard'
-                        ? 'partial'
-                        : 'collected',
-            itemCount: items.length,
-            byteCount: items.reduce((sum, item) => sum + Buffer.byteLength(item.summary ?? ''), 0),
-        };
-    });
-    if (delta.mode === 'standard') {
-        warnings.push(`Standard evidence delta selected ${delta.changedEvidenceRefs.length} changed and ${delta.requiredEvidenceRefs.length} open-item-required evidence item(s).`);
-    }
-    const evidence = {
-        kind: 'operating-evidence',
-        schemaVersion: OPERATE_SCHEMA_VERSION,
-        protocolVersion: OPERATE_PROTOCOL_VERSION,
-        cycleId: input.cycleId,
-        fingerprint: canonicalDigest({
-            workspaceDigest: input.workspace.workspaceDigest,
-            items: evidenceFingerprintItems(flattened),
-            sources,
-            delta,
-        }),
-        collectedAt: now.toISOString(),
-        truncated: truncated ||
-            flattened.length >= input.budgets.maxItems ||
-            sources.reduce((sum, source) => sum + source.byteCount, 0) >= input.budgets.maxBytes,
-        items: flattened,
-        delta,
-        sources,
-        warnings,
-    };
-    const validated = await assertOperatingArtifact('operating-evidence', evidence);
-    await writeIncrementalEvidence(input, incrementalKey, validated);
-    return validated;
-}
-/**
- * Convert commercial numbers without reproducible query/window identity into
- * governed gaps before any advisor can turn them into recommendations.
- */
-export async function unqualifiedCommercialEvidenceGaps(input) {
-    const unqualified = input.evidence.items
-        .filter((item) => item.claimTypes.includes('commercial-metric') &&
-        (!item.metric?.identity.trim() ||
-            !item.metric.query.trim() ||
-            !validIsoWindow(item.metric.observedFrom, item.metric.observedTo)))
-        .sort((left, right) => left.source.localeCompare(right.source) ||
-        left.location.localeCompare(right.location) ||
-        left.id.localeCompare(right.id));
-    const gaps = unqualified.map((item, index) => ({
-        kind: 'operating-data-gap',
-        schemaVersion: OPERATE_SCHEMA_VERSION,
-        protocolVersion: OPERATE_PROTOCOL_VERSION,
-        id: `GAP-${String(index + 1).padStart(3, '0')}`,
-        cycleId: input.cycleId,
-        question: `What reproducible metric query and observation window qualify ${item.location}?`,
-        reason: 'Numeric commercial evidence requires a metric identity, query identity, and bounded observation window before it can support an operating recommendation.',
-        unblocks: [],
-        affectedRoles: [
-            'strategy-finance',
-            'product-activation',
-            'growth-market',
-            'operations-customer',
-        ],
-        status: 'open',
-        owner: input.owner,
-        evidenceRefs: [item.id],
-        createdAt: input.now,
-        updatedAt: input.now,
-    }));
-    await Promise.all(gaps.map((gap) => assertOperatingArtifact('operating-data-gap', gap)));
-    return gaps;
-}
 export function evidenceProjectionSources(evidence) {
     return evidence.sources.map((source) => ({
         id: source.id,
@@ -1092,123 +17,4 @@ export function evidenceProjectionSources(evidence) {
         itemCount: source.itemCount,
     }));
 }
-// The Protocol v1.3 index-item schema pins these patterns; every index item we
-// emit must satisfy them or the pipeline's mission-packet validator fails
-// closed. Building here — rather than trusting the caller — keeps a malformed
-// path or revision out of a dispatched packet.
-const INDEX_PATH_PATTERN = /^(?!.*\.\.)[A-Za-z0-9][A-Za-z0-9._/-]*$/;
-const INDEX_REVISION_PATTERN = /^[a-f0-9]{7,64}$/;
-const INDEX_SOURCE_CLASSIFICATION = {
-    repository: 'source-code',
-    planr: 'planning-artifact',
-    git: 'change-history',
-    'file-import': 'imported-record',
-    github: 'integration-record',
-    linear: 'integration-record',
-};
-/**
- * Derive a stable, schema-conformant index-item id (`EVX-…`) from the source
- * evidence id. The evidence ids are unique, so the derived ids are too.
- */
-function evidenceIndexItemId(evidenceId) {
-    return `EVX-${canonicalDigest(evidenceId).slice('sha256:'.length, 27)}`;
-}
-/**
- * Strip the leading component id from an evidence `location`
- * (`<componentId>/<relativePath>`) to recover the repository-relative path, or
- * return null when the result cannot be a schema-valid index path (for example
- * dot-prefixed `.planr/…` paths, which the pattern forbids).
- */
-function evidenceIndexPath(location) {
-    const relative = location.split('/').slice(1).join('/');
-    return relative && INDEX_PATH_PATTERN.test(relative) ? relative : null;
-}
-function evidenceIndexSignals(item) {
-    const signals = new Set();
-    for (const claim of item.claimTypes) {
-        const trimmed = claim.trim();
-        if (trimmed)
-            signals.add(trimmed.slice(0, 256));
-    }
-    if (item.freshness === 'stale')
-        signals.add('stale-evidence');
-    if (item.repository?.dirtyFingerprint)
-        signals.add('uncommitted-working-tree');
-    return [...signals].sort();
-}
-/**
- * Build Protocol v1.3 evidence index items (`operating-evidence-index-item@1.3.0`)
- * from a collected evidence snapshot for mission-mode dispatch. Each item is a
- * pointer only — path OR revision, content hash, source, classification,
- * freshness, sensitivity, and detected signals — and carries NO file body. Git
- * evidence is referenced by its pinned revision; repository/planr/file-import
- * evidence by its repository-relative path. Items that cannot be represented as
- * a schema-valid path or revision pointer (github/linear records, dot-prefixed
- * planr paths) are omitted from the index rather than emitted malformed.
- */
-export function buildOperatingEvidenceIndex(evidence, options = {}) {
-    const seen = new Set();
-    const items = [];
-    for (const item of evidence.items) {
-        if (options.sensitivityCeiling &&
-            compareSensitivity(item.sensitivity, options.sensitivityCeiling) > 0) {
-            continue;
-        }
-        const source = item.source;
-        const classification = INDEX_SOURCE_CLASSIFICATION[source];
-        if (!classification)
-            continue;
-        const base = {
-            id: evidenceIndexItemId(item.id),
-            contentHash: item.digest,
-            source,
-            classification,
-            freshness: item.freshness,
-            sensitivity: item.sensitivity,
-            signals: evidenceIndexSignals(item),
-        };
-        if (seen.has(base.id))
-            continue;
-        if (source === 'git') {
-            const revision = item.repository?.revision;
-            if (revision && INDEX_REVISION_PATTERN.test(revision)) {
-                seen.add(base.id);
-                items.push({ ...base, revision });
-            }
-            continue;
-        }
-        if (source === 'repository' || source === 'planr' || source === 'file-import') {
-            const relativePath = evidenceIndexPath(item.location);
-            if (relativePath) {
-                seen.add(base.id);
-                items.push({ ...base, path: relativePath });
-            }
-        }
-    }
-    return items.sort((left, right) => {
-        if (left.source !== right.source)
-            return left.source < right.source ? -1 : 1;
-        const leftRef = left.path ?? left.revision ?? '';
-        const rightRef = right.path ?? right.revision ?? '';
-        if (leftRef !== rightRef)
-            return leftRef < rightRef ? -1 : 1;
-        return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
-    });
-}
-/**
- * The read roots a mission agent may traverse, derived from the top-level
- * directory segment of every path-referenced index item. Schema-valid and
- * deduplicated; empty when the index carries only revision pointers.
- */
-export function deriveOperatingDeclaredRoots(index) {
-    const roots = new Set();
-    for (const item of index) {
-        if (!item.path)
-            continue;
-        const top = item.path.split('/')[0];
-        if (top && INDEX_PATH_PATTERN.test(top))
-            roots.add(top);
-    }
-    return [...roots].sort();
-}
 //# sourceMappingURL=evidence.js.map