@fitlab-ai/agent-infra 0.9.2 → 0.9.4

package/dist/lib/pr-review/evidence-grading.js

@@ -0,0 +1,229 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseTaskFrontmatter } from '../task/frontmatter.js';
+export class HostResolutionError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = 'HostResolutionError';
+        this.code = code;
+    }
+}
+function toPositiveNumber(value) {
+    const n = Number(value);
+    return Number.isInteger(n) && n > 0 ? n : null;
+}
+/**
+ * Parse the PR body for closing-issue references. Handles the conventional
+ * `Closes #1` / `Fixes: #2, #3` shapes (case-insensitive, comma/space
+ * separated, optional keyword list on the same logical line).
+ */
+export function extractClosingIssueNumbers(body) {
+    const result = [];
+    const seen = new Set();
+    const linePattern = /(?:^|\n)[^\n]*\b(?:close|closes|closed|fix|fixes|fixed|resolve|resolves|resolved)\b[^\n]*/gi;
+    let lineMatch;
+    while ((lineMatch = linePattern.exec(body)) !== null) {
+        const line = lineMatch[0];
+        for (const numMatch of line.matchAll(/#(\d+)/g)) {
+            const n = Number(numMatch[1]);
+            if (Number.isInteger(n) && n > 0 && !seen.has(n)) {
+                seen.add(n);
+                result.push(n);
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Scan `.agents/workspace/active/{task-id}/task.md` files for tasks bound to the
+ * PR number or to one of the PR's closing issues. A task is emitted at most once;
+ * a direct `pr_number` hit takes priority over the issue-number reverse lookup.
+ */
+export function collectHostCandidates(input) {
+    const activeRoot = path.join(input.workspaceRoot, '.agents', 'workspace', 'active');
+    const candidates = [];
+    let entries;
+    try {
+        entries = fs.readdirSync(activeRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const taskDir = path.join(activeRoot, entry.name);
+        const taskMdPath = path.join(taskDir, 'task.md');
+        let content;
+        try {
+            content = fs.readFileSync(taskMdPath, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        const frontmatter = parseTaskFrontmatter(content);
+        const issueNumber = toPositiveNumber(frontmatter.issue_number);
+        const prNumber = toPositiveNumber(frontmatter.pr_number);
+        if (prNumber === input.prNumber) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+        else if (issueNumber !== null && input.closingIssues.includes(issueNumber)) {
+            candidates.push({ taskId: entry.name, taskDir, issueNumber, prNumber });
+        }
+    }
+    return candidates;
+}
+/**
+ * Collapse a candidate list into a typed HostResolution. Zero candidates ->
+ * none; exactly one -> unique; more than one (no stable selection rule) ->
+ * ambiguous (fail closed, AN-6).
+ */
+export function resolveHostFromCandidates(candidates) {
+    if (candidates.length === 0)
+        return { kind: 'none' };
+    if (candidates.length === 1) {
+        const candidate = candidates[0];
+        return {
+            kind: 'unique',
+            taskId: candidate.taskId,
+            taskDir: candidate.taskDir,
+            issueNumber: candidate.issueNumber ?? 0,
+            prNumber: candidate.prNumber ?? 0
+        };
+    }
+    return {
+        kind: 'ambiguous',
+        candidates: candidates.map((candidate) => ({ taskId: candidate.taskId, issueNumber: candidate.issueNumber ?? 0 }))
+    };
+}
+function hasNoLifecycleArtifacts(presence) {
+    return !presence.hasAnalysis && !presence.hasPlan && !presence.hasCode &&
+        !presence.hasReviewAnalysis && !presence.hasReviewPlan && !presence.hasReviewCode &&
+        !presence.hasPriorPrReview;
+}
+function hasFullArtifacts(presence) {
+    return presence.hasAnalysis && presence.hasPlan && presence.hasCode &&
+        presence.hasReviewAnalysis && presence.hasReviewPlan && presence.hasReviewCode;
+}
+function isTrusted(head) {
+    return head.issueNumberBound && head.taskIssueMatches && (!head.prNumberBound || head.taskPrMatches);
+}
+/**
+ * Derive the S1(a) trust factor `taskIssueMatches` (PL-3) mechanically from
+ * resolved data: a unique host is trusted on the issue dimension only when the
+ * task's bound issue_number is among the PR's closing issues. Ambiguous/none
+ * hosts and tasks without a positive issue_number cannot be confirmed -> false
+ * (fail closed to S2/audit). `resolve-host` emits this value so the prompt layer
+ * does not derive the trust factor ad hoc (CD-2).
+ */
+export function deriveTaskIssueMatches(host, closingIssues) {
+    return host.kind === 'unique' && host.issueNumber > 0 && closingIssues.includes(host.issueNumber);
+}
+/**
+ * S1 -> S2 -> S3 classification (analysis §6.1). The ambiguous host is rejected
+ * before classification (AN-6 fail closed). S3(a) is host.kind === 'none';
+ * S3(b) is a unique task with no lifecycle artifacts and no prior pr-review
+ * (PL-5/PL-9 symmetric: any review-only task falls to S2).
+ */
+export function classifyScenario(host, presence, head) {
+    if (host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'multiple candidate hosts; resolve before evidence classification');
+    }
+    if (host.kind === 'none')
+        return 'S3';
+    if (hasNoLifecycleArtifacts(presence))
+        return 'S3';
+    const priorHeadMatches = presence.hasPriorPrReview && head.priorHeadSha !== null && head.priorHeadSha === head.currentHeadSha;
+    if (hasFullArtifacts(presence) && priorHeadMatches && isTrusted(head))
+        return 'S1';
+    return 'S2';
+}
+/**
+ * Freshness is benchmarked against the prior `pr-review*` reviewed head SHA
+ * (analysis §6.2, AN-7). No prior review -> n/a/n/a (first-review special case).
+ */
+export function evaluateHead(head) {
+    if (head.priorHeadSha === null)
+        return { freshness: 'n/a', alignment: 'n/a' };
+    const freshness = head.priorHeadSha === head.currentHeadSha ? 'fresh' : 'stale';
+    const aligned = freshness === 'fresh' && isTrusted(head);
+    return { freshness, alignment: aligned ? 'aligned' : 'misaligned' };
+}
+/**
+ * Pure-evidence risk aggregation (analysis §6.3, AN-5): any priority factor
+ * (sensitivity / sourceCredibility) HIGH -> HIGH; otherwise any HIGH -> MEDIUM;
+ * all LOW -> LOW. Identity factors are structurally absent from the input type.
+ */
+export function gradeRisk(factors) {
+    const priority = [factors.sensitivity, factors.sourceCredibility];
+    if (priority.includes('HIGH'))
+        return 'HIGH';
+    const values = Object.values(factors);
+    if (values.includes('HIGH'))
+        return 'MEDIUM';
+    return 'LOW';
+}
+/**
+ * verify / audit / reconstruct selection matrix (analysis §6.4). S3 ->
+ * reconstruct; S2 -> audit; S1 fresh+aligned -> verify (LOW/MEDIUM risk) or
+ * audit (HIGH risk); any other S1 combination falls back to audit.
+ */
+export function selectMode(scenario, freshness, alignment, risk) {
+    if (scenario === 'S3')
+        return 'reconstruct';
+    if (scenario === 'S2')
+        return 'audit';
+    if (freshness === 'fresh' && alignment === 'aligned') {
+        return risk === 'HIGH' ? 'audit' : 'verify';
+    }
+    return 'audit';
+}
+function buildReason(input) {
+    const pieces = [];
+    if (input.firstReview)
+        pieces.push('first review (no prior pr-review head)');
+    if (input.hasPriorPrReview)
+        pieces.push(`prior head ${input.freshness}`);
+    if (input.freshness === 'fresh')
+        pieces.push(`alignment ${input.alignment}`);
+    pieces.push(`evidence scenario ${input.scenario}`);
+    pieces.push(`risk ${input.risk}`);
+    pieces.push(`mode ${input.mode}`);
+    return pieces.join('; ');
+}
+/**
+ * Full decision pipeline: classify -> freshness/alignment -> risk -> mode,
+ * producing a traceable DecisionRecord (AC3). Ambiguous hosts are rejected
+ * before any classification runs (AN-6).
+ */
+export function decide(input) {
+    if (input.host.kind === 'ambiguous') {
+        throw new HostResolutionError('HOST_AMBIGUOUS', 'ambiguous host; resolve before evidence classification');
+    }
+    const scenario = classifyScenario(input.host, input.presence, input.head);
+    const { freshness, alignment } = evaluateHead(input.head);
+    const risk = gradeRisk(input.riskFactors);
+    const mode = selectMode(scenario, freshness, alignment, risk);
+    const firstReview = !input.presence.hasPriorPrReview;
+    return {
+        host: input.host,
+        scenario,
+        freshness,
+        alignment,
+        risk,
+        mode,
+        firstReview,
+        reason: buildReason({
+            scenario,
+            freshness,
+            alignment,
+            risk,
+            mode,
+            firstReview,
+            hasPriorPrReview: input.presence.hasPriorPrReview
+        })
+    };
+}
+export { hasFullArtifacts, hasNoLifecycleArtifacts, isTrusted };
+//# sourceMappingURL=evidence-grading.js.map

package/dist/lib/process-data/index.js

@@ -0,0 +1,239 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { detectRepoRoot } from '../task/resolve-ref.js';
+import { normalizeObjects } from './normalize.js';
+import { reconcileRecords } from './reconcile.js';
+import { readAppliedOverlays, repairSnapshot } from './repair.js';
+import { collectGitHubObjects, collectLocalObjects } from './sources.js';
+import { canonicalJsonBytes, createObjectStore, publishSnapshot, verifySnapshot } from './store.js';
+const USAGE = `Usage: ai data <command> [options]
+
+Commands:
+  capture [--source all|local|github] [--root <dir>] [--include-excerpts]
+  verify <snapshot-id> [--root <dir>]
+  audit <snapshot-id> [--root <dir>] [--format json|text]
+  repair <snapshot-id> [--root <dir>] [--apply]
+  export <snapshot-id> [--root <dir>] [--repairs none|applied] [--output <file|->]
+`;
+function parseArgs(args, valueOptions, booleanOptions) {
+    const positionals = [];
+    const options = new Map();
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg.startsWith('--')) {
+            positionals.push(arg);
+            continue;
+        }
+        if (booleanOptions.has(arg)) {
+            if (options.has(arg))
+                throw new Error(`duplicate option: ${arg}`);
+            options.set(arg, true);
+            continue;
+        }
+        if (!valueOptions.has(arg))
+            throw new Error(`unknown option: ${arg}`);
+        const value = args[index + 1];
+        if (!value || value.startsWith('--'))
+            throw new Error(`missing value for ${arg}`);
+        if (options.has(arg))
+            throw new Error(`duplicate option: ${arg}`);
+        options.set(arg, value);
+        index += 1;
+    }
+    return { positionals, options };
+}
+function dataRoot(repoRoot, requested) {
+    const workspace = path.resolve(repoRoot, '.agents', 'workspace');
+    const resolved = path.resolve(repoRoot, requested ?? path.join('.agents', 'workspace', 'process-data'));
+    const relative = path.relative(repoRoot, resolved);
+    if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+        throw new Error('data root must be inside the repository');
+    const taskRoots = ['active', 'blocked', 'completed', 'archive'].map((state) => path.join(workspace, state));
+    if (resolved === workspace || taskRoots.some((taskRoot) => resolved === taskRoot || resolved.startsWith(`${taskRoot}${path.sep}`))) {
+        throw new Error('data root cannot be the workspace root or a task directory');
+    }
+    let current = resolved;
+    while (current !== repoRoot) {
+        if (fs.existsSync(current) && fs.lstatSync(current).isSymbolicLink())
+            throw new Error('data root cannot traverse a symlink');
+        current = path.dirname(current);
+    }
+    return resolved;
+}
+function repositoryIdentity(repoRoot) {
+    try {
+        return execFileSync('git', ['config', '--get', 'remote.origin.url'], { cwd: repoRoot, encoding: 'utf8' }).trim() || path.basename(repoRoot);
+    }
+    catch {
+        return path.basename(repoRoot);
+    }
+}
+function writeJson(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+function optionString(parsed, name) {
+    const value = parsed.options.get(name);
+    return typeof value === 'string' ? value : undefined;
+}
+function capture(args) {
+    const parsed = parseArgs(args, new Set(['--source', '--root']), new Set(['--include-excerpts']));
+    if (parsed.positionals.length > 0)
+        throw new Error('capture does not accept positional arguments');
+    const scope = optionString(parsed, '--source') ?? 'all';
+    if (!['all', 'local', 'github'].includes(scope))
+        throw new Error('--source must be all, local, or github');
+    const repoRoot = detectRepoRoot();
+    const root = dataRoot(repoRoot, optionString(parsed, '--root'));
+    const observedFrom = new Date().toISOString();
+    const objects = [];
+    const endpoints = [];
+    let repository = repositoryIdentity(repoRoot);
+    if (scope === 'all' || scope === 'local') {
+        const local = collectLocalObjects(repoRoot, { includeExcerpts: parsed.options.has('--include-excerpts') });
+        if (!local.ok) {
+            writeJson({ ok: false, error: local.error });
+            return 2;
+        }
+        objects.push(...local.value);
+    }
+    if (scope === 'all' || scope === 'github') {
+        const github = collectGitHubObjects(repoRoot);
+        if (!github.ok) {
+            writeJson({ ok: false, error: github.error });
+            return 2;
+        }
+        objects.push(...github.value.objects);
+        endpoints.push(...github.value.endpoints);
+        repository = github.value.repository;
+    }
+    const store = createObjectStore(root);
+    for (const object of objects) {
+        if (object.content !== undefined && object.disposition?.state === 'included') {
+            const stored = store.put(Buffer.from(object.content, 'utf8'));
+            if (stored.sha256 !== object.sha256)
+                throw new Error(`source hash mismatch: ${object.sourceIdentity}`);
+        }
+    }
+    const records = normalizeObjects(objects);
+    const reconciliation = reconcileRecords(records, scope);
+    const observedTo = new Date().toISOString();
+    const published = publishSnapshot(root, {
+        scope: scope,
+        repository,
+        observedFrom,
+        observedTo,
+        objects: objects.map(({ content: _content, ...object }) => object),
+        endpoints,
+        excerptsEnabled: parsed.options.has('--include-excerpts'),
+        records,
+        quality: reconciliation.findings,
+        repairs: reconciliation.repairs
+    });
+    writeJson({ ok: true, snapshotId: published.snapshotId, scope, created: published.created, objects: objects.length, records: records.length });
+    return 0;
+}
+function verify(args) {
+    const parsed = parseArgs(args, new Set(['--root']), new Set());
+    if (parsed.positionals.length !== 1)
+        throw new Error('verify requires one snapshot id');
+    const repoRoot = detectRepoRoot();
+    const result = verifySnapshot(dataRoot(repoRoot, optionString(parsed, '--root')), parsed.positionals[0]);
+    writeJson(result);
+    return result.ok ? 0 : 1;
+}
+function audit(args) {
+    const parsed = parseArgs(args, new Set(['--root', '--format']), new Set());
+    if (parsed.positionals.length !== 1)
+        throw new Error('audit requires one snapshot id');
+    const format = optionString(parsed, '--format') ?? 'text';
+    if (!['json', 'text'].includes(format))
+        throw new Error('--format must be json or text');
+    const repoRoot = detectRepoRoot();
+    const root = dataRoot(repoRoot, optionString(parsed, '--root'));
+    const verified = verifySnapshot(root, parsed.positionals[0]);
+    if (!verified.ok || !verified.snapshotPath || !verified.manifest) {
+        writeJson(verified);
+        return 1;
+    }
+    const quality = JSON.parse(fs.readFileSync(path.join(verified.snapshotPath, 'quality.json'), 'utf8'));
+    const records = fs.readFileSync(path.join(verified.snapshotPath, 'normalized.jsonl'), 'utf8').split('\n').filter(Boolean).map((line) => {
+        const { schema: _schema, ...record } = JSON.parse(line);
+        return record;
+    });
+    const recomputed = reconcileRecords(records, verified.manifest.scope);
+    if (!canonicalJsonBytes(recomputed.findings).equals(canonicalJsonBytes(quality.findings))) {
+        writeJson({ ok: false, error: { code: 'QUALITY_MISMATCH', message: 'stored quality baseline does not match recomputed findings' } });
+        return 1;
+    }
+    if (format === 'json')
+        writeJson({ ok: true, snapshotId: parsed.positionals[0], findings: recomputed.findings });
+    else
+        process.stdout.write(`Snapshot ${parsed.positionals[0]}: ${quality.findings.length} findings\n`);
+    return 0;
+}
+function repair(args) {
+    const parsed = parseArgs(args, new Set(['--root']), new Set(['--apply']));
+    if (parsed.positionals.length !== 1)
+        throw new Error('repair requires one snapshot id');
+    const repoRoot = detectRepoRoot();
+    const result = repairSnapshot(dataRoot(repoRoot, optionString(parsed, '--root')), parsed.positionals[0], parsed.options.has('--apply'));
+    writeJson({ ok: true, ...result });
+    return 0;
+}
+function exportSnapshot(args) {
+    const parsed = parseArgs(args, new Set(['--root', '--repairs', '--output']), new Set());
+    if (parsed.positionals.length !== 1)
+        throw new Error('export requires one snapshot id');
+    const repairMode = optionString(parsed, '--repairs') ?? 'none';
+    if (!['none', 'applied'].includes(repairMode))
+        throw new Error('--repairs must be none or applied');
+    const output = optionString(parsed, '--output') ?? '-';
+    const repoRoot = detectRepoRoot();
+    const root = dataRoot(repoRoot, optionString(parsed, '--root'));
+    const verified = verifySnapshot(root, parsed.positionals[0]);
+    if (!verified.ok || !verified.snapshotPath) {
+        writeJson(verified);
+        return 1;
+    }
+    let content = fs.readFileSync(path.join(verified.snapshotPath, 'normalized.jsonl'), 'utf8');
+    if (repairMode === 'applied')
+        content += readAppliedOverlays(root, parsed.positionals[0]);
+    if (output === '-')
+        process.stdout.write(content);
+    else {
+        const destination = path.resolve(repoRoot, output);
+        const relative = path.relative(repoRoot, destination);
+        if (!relative || relative.startsWith('..') || path.isAbsolute(relative))
+            throw new Error('export output must be inside the repository');
+        fs.writeFileSync(destination, content, { flag: 'wx', mode: 0o600 });
+        writeJson({ ok: true, snapshotId: parsed.positionals[0], output: relative });
+    }
+    return 0;
+}
+async function cmdData(args) {
+    const [command, ...rest] = args;
+    if (!command || command === '--help' || command === '-h' || command === 'help') {
+        process.stdout.write(USAGE);
+        return command ? 0 : 1;
+    }
+    try {
+        switch (command) {
+            case 'capture': return capture(rest);
+            case 'verify': return verify(rest);
+            case 'audit': return audit(rest);
+            case 'repair': return repair(rest);
+            case 'export': return exportSnapshot(rest);
+            default:
+                process.stderr.write(`Unknown data command: ${command}\n`);
+                process.stdout.write(USAGE);
+                return 1;
+        }
+    }
+    catch (error) {
+        writeJson({ ok: false, error: { code: 'DATA_COMMAND_FAILED', message: error instanceof Error ? error.message : String(error) } });
+        return 1;
+    }
+}
+export { cmdData, dataRoot };
+//# sourceMappingURL=index.js.map

package/dist/lib/process-data/normalize.js

@@ -0,0 +1,198 @@
+import { sha256 } from './store.js';
+const TASK_ID_RE = /TASK-\d{8}-\d{6}/;
+const ACTIVITY_RE = /^- (\d{4}-\d{2}-\d{2} [^ ]+) — \*\*(.+?)\*\* by ([^ ]+) — (.+)$/gm;
+const LEDGER_RE = /^\|\s*((?:AN|PL|CD)-\d+)\s*\|\s*(analysis|plan|code)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|$/gm;
+const RULING_RE = /^###\s+(HDR-\d+)\s*$([\s\S]*?)(?=^###\s+|^##\s+|(?![\s\S]))/gm;
+const CONFLICT_STATUSES = new Set(['open', 'accepted', 'adjusted', 'refuted', 'cannot-judge', 'needs-human-decision']);
+function recordId(kind, identity, suffix = '') {
+    return `${kind}:${sha256(`${identity}\0${suffix}`).slice(0, 24)}`;
+}
+function canonicalActor(raw) {
+    const lowered = raw.toLowerCase();
+    const aliases = {
+        'claude-code': 'claude',
+        'antigravity-cli': 'antigravity',
+        'gemini-cli': 'gemini',
+        gemini: 'gemini'
+    };
+    if (['claude', 'codex', 'antigravity', 'opencode', 'cursor', 'human'].includes(lowered))
+        return lowered;
+    return aliases[lowered] ?? null;
+}
+function nextOccurrence(occurrences, identity) {
+    const occurrence = (occurrences.get(identity) ?? 0) + 1;
+    occurrences.set(identity, occurrence);
+    return occurrence === 1 ? '' : `occurrence=${occurrence}`;
+}
+function normalizePlatformPage(object) {
+    if (!object.content)
+        return [];
+    try {
+        const page = JSON.parse(object.content);
+        if (!Array.isArray(page))
+            return [];
+        return page.map((entry, index) => {
+            const value = entry;
+            const identity = String(value.id ?? value.node_id ?? value.sha ?? value.number ?? `${object.sourceIdentity}:${index}`);
+            const platformIdentity = /\/issues\?/.test(object.sourceIdentity) && typeof value.number === 'number'
+                ? `issue:${value.number}`
+                : /\/pulls\?/.test(object.sourceIdentity) && typeof value.number === 'number'
+                    ? `pr:${value.number}`
+                    : /\/issues\/\d+\/comments/.test(object.sourceIdentity)
+                        ? `issue-comment:${identity}`
+                        : /\/pulls\/\d+\/reviews/.test(object.sourceIdentity)
+                            ? `review:${identity}`
+                            : /\/pulls\/\d+\/commits/.test(object.sourceIdentity)
+                                ? `commit:${identity}`
+                                : `platform:${identity}`;
+            const binding = typeof value.body === 'string' ? value.body.match(TASK_ID_RE)?.[0] : undefined;
+            return {
+                recordId: recordId('platform-resource', object.sourceIdentity, identity),
+                kind: 'platform-resource',
+                sourceIdentity: platformIdentity,
+                sourceSha256: object.sha256,
+                ...(binding ? { binding } : {}),
+                data: entry
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function normalizeObjects(objects) {
+    const records = [];
+    for (const object of objects) {
+        if (object.disposition?.state && object.disposition.state !== 'included') {
+            records.push({
+                recordId: recordId('missing', object.sourceIdentity),
+                kind: 'missing',
+                sourceIdentity: object.sourceIdentity,
+                sourceSha256: object.sha256,
+                data: object.disposition.state === 'excluded-sensitive'
+                    ? { reason: 'privacy-excluded', ruleId: object.disposition.ruleId }
+                    : { reason: object.disposition.reason }
+            });
+            continue;
+        }
+        if (object.sourceKind === 'github-rest') {
+            records.push(...normalizePlatformPage(object));
+            continue;
+        }
+        if (object.sourceKind === 'operational-report') {
+            records.push({
+                recordId: recordId('operational-report', object.sourceIdentity),
+                kind: 'operational-report',
+                sourceIdentity: object.sourceIdentity,
+                sourceSha256: object.sha256
+            });
+            continue;
+        }
+        if (object.sourceKind === 'structured-telemetry') {
+            let data = { availability: 'unknown' };
+            try {
+                data = JSON.parse(object.content ?? '{}');
+            }
+            catch {
+                data = { availability: 'unavailable', reason: 'invalid receipt JSON' };
+            }
+            records.push({
+                recordId: recordId('telemetry', object.sourceIdentity),
+                kind: 'telemetry',
+                sourceIdentity: object.sourceIdentity,
+                sourceSha256: object.sha256,
+                data
+            });
+            continue;
+        }
+        const taskId = object.sourceIdentity.match(TASK_ID_RE)?.[0];
+        if (/\/task\.md$/.test(object.sourceIdentity) && taskId) {
+            const activityOccurrences = new Map();
+            const findingOccurrences = new Map();
+            const issueNumber = object.content?.match(/^issue_number:\s*(\d+)$/m)?.[1];
+            const agentInfraVersion = object.content?.match(/^agent_infra_version:\s*(\S+)$/m)?.[1];
+            records.push({
+                recordId: recordId('task', taskId),
+                kind: 'task',
+                sourceIdentity: taskId,
+                sourceSha256: object.sha256,
+                ...(issueNumber ? { binding: `issue:${issueNumber}` } : {}),
+                data: {
+                    agentInfraVersion: agentInfraVersion
+                        ? { state: 'known', value: agentInfraVersion }
+                        : { state: 'unknown', reason: 'legacy-task-missing-agent-infra-version' }
+                }
+            });
+            for (const match of object.content?.matchAll(ACTIVITY_RE) ?? []) {
+                const rawActor = match[3];
+                const identity = `${match[1]}:${match[2]}`;
+                const occurrence = nextOccurrence(activityOccurrences, identity);
+                records.push({
+                    recordId: recordId('lifecycle-event', taskId, occurrence ? `${identity}\0${occurrence}` : identity),
+                    kind: 'lifecycle-event',
+                    sourceIdentity: `${taskId}#activity=${match[1]}`,
+                    sourceSha256: object.sha256,
+                    data: {
+                        timestamp: match[1],
+                        action: match[2],
+                        actorRaw: rawActor,
+                        actorCanonical: canonicalActor(rawActor),
+                        note: match[4]
+                    }
+                });
+            }
+            for (const match of object.content?.matchAll(LEDGER_RE) ?? []) {
+                const findingId = match[1].trim();
+                const stage = match[2].trim();
+                const round = match[3].trim();
+                const severity = match[4].trim();
+                const status = match[5].trim();
+                const evidence = match[6].trim();
+                const identity = `${taskId}#finding=${findingId}`;
+                const occurrence = nextOccurrence(findingOccurrences, identity);
+                const data = { findingId, stage, round, severity, status, evidence };
+                records.push({
+                    recordId: recordId('review-finding', identity, occurrence),
+                    kind: 'review-finding',
+                    sourceIdentity: identity,
+                    sourceSha256: object.sha256,
+                    binding: taskId,
+                    data
+                });
+                if (status && CONFLICT_STATUSES.has(status)) {
+                    records.push({
+                        recordId: recordId('conflict', identity, occurrence),
+                        kind: 'conflict',
+                        sourceIdentity: `${identity}#status=${status}`,
+                        sourceSha256: object.sha256,
+                        binding: taskId,
+                        data
+                    });
+                }
+            }
+            for (const match of object.content?.matchAll(RULING_RE) ?? []) {
+                const rulingId = match[1];
+                const identity = `${taskId}#ruling=${rulingId}`;
+                records.push({
+                    recordId: recordId('human-ruling', identity),
+                    kind: 'human-ruling',
+                    sourceIdentity: identity,
+                    sourceSha256: object.sha256,
+                    binding: taskId,
+                    data: { rulingId, evidence: match[2].trim() }
+                });
+            }
+            continue;
+        }
+        records.push({
+            recordId: recordId('artifact', object.sourceIdentity),
+            kind: 'artifact',
+            sourceIdentity: object.sourceIdentity,
+            sourceSha256: object.sha256,
+            ...(taskId ? { binding: taskId } : {})
+        });
+    }
+    return records.sort((left, right) => left.recordId.localeCompare(right.recordId));
+}
+export { normalizeObjects };
+//# sourceMappingURL=normalize.js.map