rea-agents 3.0.0 → 3.2.0

package/dist/application/CrossVersionInvestigation.js

@@ -1,301 +0,0 @@
-import {} from "../domain/evidence.js";
-import { createEvidenceBundle, } from "../domain/evidenceBundle.js";
-import { AnalysisCancelledError, AnalysisInputError, EvidenceIntegrityError, InvestigationWorkspaceError, } from "../domain/errors.js";
-import { createLegacyInvestigationRunIdentity, createInvestigationRunIdentity, createInvestigationWorkspace, crossVersionInvestigationInputSchema, investigationRunSchema, reviseInvestigationWorkspace, } from "../domain/investigationWorkspace.js";
-import { err, ok } from "../domain/result.js";
-import { createInventoryEvidencePages, runLimitations, scanVersions, targetFor, } from "./CrossVersionInventory.js";
-import { readInvestigationWorkspace, writeInvestigationWorkspace, } from "./InvestigationWorkspaceStore.js";
-import { createArtifactComparisonEvidence, createChangedBehaviorEvidence, } from "./CrossVersionInvestigationEvidence.js";
-import { selectCompletedInvestigationReplay } from "./CrossVersionInvestigationReplay.js";
-import { investigationEvidenceIds as evidenceIds, mergeInvestigationEvidence as mergeEvidence, recordsForInvestigationRun as recordsForRun, replaceInvestigationRun as replaceRun, } from "./CrossVersionInvestigationCollections.js";
-/** Run or resume a deterministic cross-version artifact investigation. */
-export const runCrossVersionInvestigation = async (input, policy, execution) => {
-    const parsed = crossVersionInvestigationInputSchema.safeParse(input);
-    if (!parsed.success)
-        return err(new AnalysisInputError("find_changed_behavior", {
-            cause: parsed.error,
-        }));
-    return runCrossVersionInvestigationValidated(parsed.data, policy, execution);
-};
-/** Run input already parsed by a trusted adapter boundary. */
-export const runCrossVersionInvestigationValidated = async (input, policy, execution) => {
-    const initial = await readInvestigationWorkspace(input.workspace_path, policy);
-    if (!initial.ok)
-        return initial;
-    const preflight = validateWorkspaceRequest(initial.value, input);
-    if (!preflight.ok)
-        return preflight;
-    if (isCancelled(execution.signal))
-        return err(new AnalysisCancelledError("find_changed_behavior"));
-    if (input.replay_run_id !== undefined) {
-        const replay = selectCompletedInvestigationReplay(initial.value, input);
-        if (!replay.ok)
-            return replay;
-        return completeOutcome(replay.value.workspace, replay.value.run, true, execution.session);
-    }
-    if (execution.authorizeInputRead !== undefined) {
-        const authorized = await execution.authorizeInputRead();
-        if (!authorized.ok)
-            return authorized;
-    }
-    await execution.progress?.report({
-        phase: "scan_versions",
-        completed: 0,
-        total: 4,
-        message: "Scanning both version inputs",
-    });
-    const snapshots = await scanVersions(input, execution.inputRoots, execution.signal, execution.integrityContinueEnabled);
-    if (!snapshots.ok)
-        return snapshots;
-    await execution.progress?.report({
-        phase: "scan_versions",
-        completed: 1,
-        total: 4,
-        message: "Version inputs scanned",
-    });
-    return continueInvestigation({
-        input,
-        initial: initial.value,
-        snapshots: snapshots.value,
-        policy,
-        session: execution.session,
-        signal: execution.signal,
-        progress: execution.progress,
-        authorizeWorkspaceWrite: execution.authorizeWorkspaceWrite,
-    });
-};
-const continueInvestigation = async (context) => {
-    const left = targetFor(context.snapshots.left);
-    const right = targetFor(context.snapshots.right);
-    const identity = createInvestigationRunIdentity({
-        left,
-        right,
-        options: context.input.options,
-        integrity_policy: context.input.integrity_policy,
-        integrity_continue_approved: context.input.integrity_continue_approved,
-        max_integrity_mismatches: context.input.max_integrity_mismatches,
-    });
-    const legacyIdentity = createLegacyInvestigationRunIdentity({
-        left,
-        right,
-        options: context.input.options,
-    });
-    const existing = context.initial?.runs.find((run) => run.run_id === identity.runId ||
-        (context.input.integrity_policy === "fail" &&
-            !context.input.integrity_continue_approved &&
-            context.input.max_integrity_mismatches === 10 &&
-            "legacy_request_identity" in run &&
-            run.max_integrity_mismatches === 10 &&
-            run.run_id === legacyIdentity.runId));
-    if (context.initial !== null && existing?.status === "complete")
-        return completeOutcome(context.initial, existing, true, context.session);
-    if (context.authorizeWorkspaceWrite !== undefined) {
-        const authorized = await context.authorizeWorkspaceWrite();
-        if (!authorized.ok)
-            return authorized;
-    }
-    const pages = createInventoryEvidencePages(context.input, context.snapshots);
-    if (!pages.ok)
-        return pages;
-    if (isCancelled(context.signal))
-        return err(new AnalysisCancelledError("find_changed_behavior"));
-    const inventoried = await ensureInventoryCheckpoint({
-        input: context.input,
-        current: context.initial,
-        existing,
-        pages: pages.value,
-        snapshots: context.snapshots,
-        policy: context.policy,
-    });
-    if (!inventoried.ok)
-        return inventoried;
-    await context.progress?.report({
-        phase: "inventory_versions",
-        completed: 2,
-        total: 4,
-        message: "Both artifact inventories checkpointed",
-    });
-    if (isCancelled(context.signal))
-        return err(new AnalysisCancelledError("find_changed_behavior"));
-    const compared = await ensureComparisonCheckpoint(context.input, inventoried.value, context.policy);
-    if (!compared.ok)
-        return compared;
-    await context.progress?.report({
-        phase: "compare_artifacts",
-        completed: 3,
-        total: 4,
-        message: "Artifact comparison checkpointed",
-    });
-    if (isCancelled(context.signal))
-        return err(new AnalysisCancelledError("find_changed_behavior"));
-    const finalized = await finalizeInvestigation(context.input, compared.value, context.policy, context.session);
-    await context.progress?.report({
-        phase: "changed_behavior",
-        completed: 4,
-        total: 4,
-        message: finalized.ok ? "Investigation completed" : "Investigation failed",
-        terminal: true,
-    });
-    return finalized;
-};
-const isCancelled = (signal) => signal?.aborted === true;
-const ensureInventoryCheckpoint = async (input) => {
-    if (input.existing !== undefined) {
-        const consistent = validateInventoryCheckpoint(input.existing, input.pages);
-        if (!consistent.ok)
-            return consistent;
-        return input.current === null
-            ? err(new EvidenceIntegrityError("Investigation workspace is missing"))
-            : ok({ workspace: input.current, run: input.existing });
-    }
-    const left = targetFor(input.snapshots.left);
-    const right = targetFor(input.snapshots.right);
-    const identity = createInvestigationRunIdentity({
-        left,
-        right,
-        options: input.input.options,
-        integrity_policy: input.input.integrity_policy,
-        integrity_continue_approved: input.input.integrity_continue_approved,
-        max_integrity_mismatches: input.input.max_integrity_mismatches,
-    });
-    const run = investigationRunSchema.parse({
-        schema_version: 1,
-        run_id: identity.runId,
-        request_sha256: identity.requestSha256,
-        left,
-        right,
-        options: input.input.options,
-        integrity_policy: input.input.integrity_policy,
-        integrity_continue_approved: input.input.integrity_continue_approved,
-        max_integrity_mismatches: input.input.max_integrity_mismatches,
-        status: "running",
-        completed_stages: ["inventory_left", "inventory_right"],
-        left_inventory_evidence_ids: evidenceIds(input.pages.left),
-        right_inventory_evidence_ids: evidenceIds(input.pages.right),
-        comparison_evidence_id: null,
-        result_evidence_id: null,
-        limitations: runLimitations(input.snapshots),
-    });
-    const saved = await checkpoint({
-        path: input.input.workspace_path,
-        name: input.input.workspace_name,
-        current: input.current,
-        records: [...input.pages.left, ...input.pages.right],
-        run,
-        policy: input.policy,
-    });
-    return saved.ok ? ok({ workspace: saved.value, run }) : saved;
-};
-const ensureComparisonCheckpoint = async (input, state, policy) => {
-    if (state.run.comparison_evidence_id !== null)
-        return ok(state);
-    const inventory = inventoryEvidence(state.workspace, state.run);
-    if (!inventory.ok)
-        return inventory;
-    const evidence = createArtifactComparisonEvidence(inventory.value, input.options.change_limit);
-    const run = investigationRunSchema.parse({
-        ...state.run,
-        completed_stages: [
-            "inventory_left",
-            "inventory_right",
-            "compare_artifacts",
-        ],
-        comparison_evidence_id: evidence.evidence_id,
-    });
-    const saved = await checkpoint({
-        path: input.workspace_path,
-        name: input.workspace_name,
-        current: state.workspace,
-        records: [evidence],
-        run,
-        policy,
-    });
-    return saved.ok ? ok({ workspace: saved.value, run }) : saved;
-};
-const finalizeInvestigation = async (input, state, policy, session) => {
-    const comparison = comparisonEvidenceFor(state.workspace, state.run);
-    if (!comparison.ok)
-        return comparison;
-    const evidence = createChangedBehaviorEvidence(state.workspace, state.run, comparison.value);
-    const run = investigationRunSchema.parse({
-        ...state.run,
-        status: "complete",
-        completed_stages: [
-            "inventory_left",
-            "inventory_right",
-            "compare_artifacts",
-            "find_changed_behavior",
-        ],
-        result_evidence_id: evidence.evidence_id,
-    });
-    const saved = await checkpoint({
-        path: input.workspace_path,
-        name: input.workspace_name,
-        current: state.workspace,
-        records: [evidence],
-        run,
-        policy,
-    });
-    return saved.ok ? completeOutcome(saved.value, run, false, session) : saved;
-};
-const comparisonEvidenceFor = (workspace, run) => {
-    const evidence = workspace.bundle.records.find(({ evidence_id: id }) => id === run.comparison_evidence_id);
-    return evidence === undefined
-        ? err(new EvidenceIntegrityError("Investigation comparison checkpoint is missing Evidence"))
-        : ok(evidence);
-};
-const checkpoint = async (input) => {
-    const records = mergeEvidence(input.current?.bundle.records ?? [], input.records);
-    const bundle = createEvidenceBundle(records, input.current?.bundle.unknowns ?? []);
-    const runs = replaceRun(input.current?.runs ?? [], input.run);
-    const next = input.current === null
-        ? createInvestigationWorkspace(input.name, bundle, runs)
-        : reviseInvestigationWorkspace(input.current, bundle, runs);
-    const written = await writeInvestigationWorkspace(next, input.path, input.current?.revision ?? null, input.policy);
-    return written.ok ? ok(next) : written;
-};
-const completeOutcome = (workspace, run, reused, session) => {
-    if (run.result_evidence_id === null)
-        return err(new EvidenceIntegrityError("Completed investigation has no result"));
-    const evidence = workspace.bundle.records.find(({ evidence_id: id }) => id === run.result_evidence_id);
-    if (evidence === undefined)
-        return err(new EvidenceIntegrityError("Completed investigation result Evidence is missing"));
-    if (session !== undefined) {
-        const records = recordsForRun(workspace, run);
-        const imported = session.importEvidenceBundle(createEvidenceBundle(records));
-        if (!imported.ok)
-            return imported;
-    }
-    return ok({ evidence, workspace, reused });
-};
-const validateWorkspaceRequest = (workspace, input) => {
-    if (workspace !== null && workspace.name !== input.workspace_name)
-        return err(new InvestigationWorkspaceError("update", "name-conflict"));
-    if (input.expected_workspace_revision !== undefined &&
-        workspace?.revision !== input.expected_workspace_revision)
-        return err(new InvestigationWorkspaceError("update", "revision-conflict"));
-    return ok(null);
-};
-const validateInventoryCheckpoint = (run, pages) => JSON.stringify(run.left_inventory_evidence_ids) ===
-    JSON.stringify(evidenceIds(pages.left)) &&
-    JSON.stringify(run.right_inventory_evidence_ids) ===
-        JSON.stringify(evidenceIds(pages.right))
-    ? ok(null)
-    : err(new EvidenceIntegrityError("Investigation inventory checkpoint disagrees with current content"));
-const inventoryEvidence = (workspace, run) => {
-    if (workspace === null)
-        return err(new EvidenceIntegrityError("Investigation workspace is missing"));
-    const byId = new Map(workspace.bundle.records.map((record) => [record.evidence_id, record]));
-    const left = run.left_inventory_evidence_ids.flatMap((id) => {
-        const evidence = byId.get(id);
-        return evidence === undefined ? [] : [evidence];
-    });
-    const right = run.right_inventory_evidence_ids.flatMap((id) => {
-        const evidence = byId.get(id);
-        return evidence === undefined ? [] : [evidence];
-    });
-    return left.length === run.left_inventory_evidence_ids.length &&
-        right.length === run.right_inventory_evidence_ids.length
-        ? ok({ left, right })
-        : err(new EvidenceIntegrityError("Investigation inventory checkpoint is incomplete"));
-};

package/dist/application/CrossVersionInvestigationCollections.js

@@ -1,23 +0,0 @@
-export const recordsForInvestigationRun = (workspace, run) => {
-    const ids = new Set([
-        ...run.left_inventory_evidence_ids,
-        ...run.right_inventory_evidence_ids,
-        ...(run.comparison_evidence_id === null
-            ? []
-            : [run.comparison_evidence_id]),
-        ...(run.result_evidence_id === null ? [] : [run.result_evidence_id]),
-    ]);
-    return workspace.bundle.records.filter(({ evidence_id: id }) => ids.has(id));
-};
-export const mergeInvestigationEvidence = (current, additions) => {
-    const records = new Map(current.map((record) => [record.evidence_id, record]));
-    for (const record of additions)
-        if (!records.has(record.evidence_id))
-            records.set(record.evidence_id, record);
-    return [...records.values()];
-};
-export const replaceInvestigationRun = (runs, replacement) => [
-    ...runs.filter(({ run_id: id }) => id !== replacement.run_id),
-    replacement,
-];
-export const investigationEvidenceIds = (records) => records.map(({ evidence_id: id }) => id);

package/dist/application/CrossVersionInvestigationEvidence.js

@@ -1,64 +0,0 @@
-import { compareArtifacts } from "../domain/artifactComparison.js";
-import { findChangedBehavior } from "../domain/changedBehavior.js";
-import { createEvidence } from "../domain/evidence.js";
-import { investigationRunSummarySchema, } from "../domain/investigationWorkspace.js";
-import { jsonValueSchema } from "../domain/jsonValue.js";
-import { AUTOMATIC_RUN_LIMITATION } from "./CrossVersionInventory.js";
-import { ARTIFACT_COMPARISON_PROVIDER, CHANGED_BEHAVIOR_PROVIDER, } from "./InvestigationProviders.js";
-/** Derive deterministic artifact-comparison Evidence from inventory pages. */
-export const createArtifactComparisonEvidence = (inventory, limit) => {
-    const comparison = compareArtifacts(inventory.left, inventory.right, 0, limit);
-    const leftIds = evidenceIds(inventory.left);
-    const rightIds = evidenceIds(inventory.right);
-    return createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
-        predicateType: "rea.artifact-comparison/v1",
-        operation: "compare_artifacts",
-        parameters: {
-            left_evidence_ids: leftIds,
-            right_evidence_ids: rightIds,
-            offset: 0,
-            limit,
-        },
-        result: jsonValueSchema.parse(comparison),
-        confidence: "derived",
-        authority: "analyst-inference",
-        limitations: comparison.limitations,
-        evidenceLinks: [...leftIds, ...rightIds],
-    });
-};
-/** Derive the deterministic final report for one comparison checkpoint. */
-export const createChangedBehaviorEvidence = (workspace, run, comparison) => {
-    const limit = Math.min(run.options.change_limit, 100);
-    const changed = findChangedBehavior([comparison], 0, limit);
-    const summary = investigationRunSummarySchema.parse({
-        schema_version: 1,
-        workspace_id: workspace.workspace_id,
-        run_id: run.run_id,
-        left_manifest_id: run.left.manifest_id,
-        right_manifest_id: run.right.manifest_id,
-        inventory_evidence_count: run.left_inventory_evidence_ids.length +
-            run.right_inventory_evidence_ids.length,
-        comparison_evidence_id: comparison.evidence_id,
-        limitations: run.limitations,
-    });
-    return createEvidence(undefined, CHANGED_BEHAVIOR_PROVIDER, {
-        predicateType: "rea.changed-behavior/v1",
-        operation: "find_changed_behavior",
-        parameters: {
-            workspace_id: workspace.workspace_id,
-            run_id: run.run_id,
-            comparison_evidence_ids: [comparison.evidence_id],
-            offset: 0,
-            limit,
-        },
-        result: jsonValueSchema.parse({
-            ...changed,
-            investigation_run: summary,
-        }),
-        confidence: "derived",
-        authority: "analyst-inference",
-        limitations: [...changed.limitations, AUTOMATIC_RUN_LIMITATION],
-        evidenceLinks: changed.evidence_links,
-    });
-};
-const evidenceIds = (records) => records.map(({ evidence_id: id }) => id);

package/dist/application/CrossVersionInvestigationReplay.js

@@ -1,170 +0,0 @@
-import { isDeepStrictEqual } from "node:util";
-import { artifactInventoryResultSchema, } from "../domain/artifactGraph.js";
-import { parseArtifactInventoryEvidence } from "../domain/artifactInventoryEvidence.js";
-import { EvidenceIntegrityError, InvestigationWorkspaceError, } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
-import { createArtifactComparisonEvidence, createChangedBehaviorEvidence, } from "./CrossVersionInvestigationEvidence.js";
-import { AUTOMATIC_RUN_LIMITATION } from "./CrossVersionInventory.js";
-import { ARTIFACT_GRAPH_PROVIDER } from "./InvestigationProviders.js";
-/** Select and verify one caller-identified complete run without input access. */
-export const selectCompletedInvestigationReplay = (workspace, input) => {
-    const run = workspace?.runs.find(({ run_id: runId }) => runId === input.replay_run_id);
-    if (workspace === null ||
-        run === undefined ||
-        run.status !== "complete" ||
-        !controlsMatch(run, input))
-        return replayConflict();
-    const records = new Map(workspace.bundle.records.map((record) => [record.evidence_id, record]));
-    const left = inventoryRecords(records, run.left_inventory_evidence_ids);
-    const right = inventoryRecords(records, run.right_inventory_evidence_ids);
-    if (!left.ok)
-        return left;
-    if (!right.ok)
-        return right;
-    if (!pathsMatch(left.value, input.left_path) ||
-        !pathsMatch(right.value, input.right_path))
-        return replayConflict();
-    const validated = validateLinkedEvidence(workspace, run, left.value, right.value);
-    return validated.ok ? ok({ workspace, run }) : validated;
-};
-const controlsMatch = (run, input) => isDeepStrictEqual(run.options, input.options) &&
-    run.integrity_policy === input.integrity_policy &&
-    run.integrity_continue_approved === input.integrity_continue_approved &&
-    run.max_integrity_mismatches === input.max_integrity_mismatches;
-const inventoryRecords = (records, evidenceIds) => {
-    if (new Set(evidenceIds).size !== evidenceIds.length)
-        return replayIntegrity("Investigation replay repeats inventory Evidence");
-    const selected = evidenceIds.flatMap((evidenceId) => {
-        const evidence = records.get(evidenceId);
-        return evidence === undefined ? [] : [evidence];
-    });
-    return selected.length === evidenceIds.length
-        ? ok(selected)
-        : replayIntegrity("Investigation replay is missing inventory Evidence");
-};
-const pathsMatch = (records, path) => records.every(({ subject }) => subject?.local_path === path);
-const validateLinkedEvidence = (workspace, run, leftRecords, rightRecords) => {
-    try {
-        const left = validateInventory(leftRecords, run.left, run);
-        const right = validateInventory(rightRecords, run.right, run);
-        if (!left.ok)
-            return left;
-        if (!right.ok)
-            return right;
-        const expectedLimitations = runLimitations(left.value, right.value);
-        if (!isDeepStrictEqual(run.limitations, expectedLimitations))
-            return replayIntegrity("Investigation replay limitations disagree with inventory Evidence");
-        const comparison = createArtifactComparisonEvidence({ left: left.value.records, right: right.value.records }, run.options.change_limit);
-        const storedComparison = evidenceFor(workspace, run.comparison_evidence_id);
-        if (storedComparison === undefined ||
-            !isDeepStrictEqual(storedComparison, comparison))
-            return replayIntegrity("Investigation replay comparison Evidence is inconsistent");
-        const result = createChangedBehaviorEvidence(workspace, run, comparison);
-        const storedResult = evidenceFor(workspace, run.result_evidence_id);
-        return storedResult !== undefined && isDeepStrictEqual(storedResult, result)
-            ? ok(null)
-            : replayIntegrity("Investigation replay result Evidence is inconsistent");
-    }
-    catch (cause) {
-        return replayIntegrity("Investigation replay linked Evidence is invalid", cause);
-    }
-};
-const validateInventory = (records, target, run) => {
-    const pages = records.map((record) => artifactInventoryResultSchema.parse(record.normalized_result));
-    const expectedPageCount = Math.max(1, Math.ceil((pages[0]?.manifest.node_count ?? 0) / run.options.page_size), Math.ceil((pages[0]?.manifest.occurrence_count ?? 0) / run.options.page_size), Math.ceil((pages[0]?.manifest.edge_count ?? 0) / run.options.page_size));
-    if (records.length !== expectedPageCount)
-        return replayIntegrity("Investigation replay inventory Evidence pagination is inconsistent");
-    if (!sameSnapshotMetadata(pages))
-        return replayIntegrity("Investigation replay inventory pages disagree on snapshot metadata");
-    for (const [index, record] of records.entries()) {
-        const page = pages[index];
-        if (page === undefined || !inventoryRecordMatches(record, page, run, index))
-            return replayIntegrity("Investigation replay inventory Evidence is inconsistent");
-    }
-    const result = parseArtifactInventoryEvidence(records);
-    if (!result.inventory.complete || !targetMatches(result.inventory, target))
-        return replayIntegrity("Investigation replay inventory commitment is inconsistent");
-    return ok({ records, result });
-};
-const inventoryRecordMatches = (record, page, run, index) => {
-    const offset = index * run.options.page_size;
-    const parameters = {
-        node_offset: offset,
-        node_limit: run.options.page_size,
-        occurrence_offset: offset,
-        occurrence_limit: run.options.page_size,
-        edge_offset: offset,
-        edge_limit: run.options.page_size,
-        max_entries: run.options.max_entries,
-        max_total_bytes: run.options.max_total_bytes,
-        max_entry_bytes: run.options.max_entry_bytes,
-        max_compression_ratio: run.options.max_compression_ratio,
-        max_depth: run.options.max_depth,
-        max_path_bytes: run.options.max_path_bytes,
-        integrity_policy: run.integrity_policy,
-        integrity_continue_approved: run.integrity_continue_approved,
-        max_integrity_mismatches: run.max_integrity_mismatches,
-    };
-    const locations = page.occurrences.items.map(({ logical_path: path }) => ({
-        kind: "artifact-path",
-        path,
-    }));
-    return (record.subject !== null &&
-        record.subject.name === record.subject.local_path.split("/").at(-1) &&
-        record.subject.digest.sha256 === page.manifest.root_sha256 &&
-        record.subject.format === page.manifest.root_format &&
-        record.subject.architecture === null &&
-        isDeepStrictEqual(record.provider, ARTIFACT_GRAPH_PROVIDER) &&
-        record.predicate_type === "rea.analysis/v2" &&
-        record.operation === "inventory_artifact" &&
-        isDeepStrictEqual(record.parameters, parameters) &&
-        record.raw_result === null &&
-        record.confidence === "observed" &&
-        record.authority === "shipped-artifact" &&
-        record.environment === null &&
-        isDeepStrictEqual(record.limitations, page.limitations) &&
-        isDeepStrictEqual(record.locations, locations) &&
-        record.evidence_links.length === 0 &&
-        isDeepStrictEqual(page.limits, traversalLimits(run)) &&
-        pageMatches(page.nodes, offset, run.options.page_size, page.manifest.node_count) &&
-        pageMatches(page.occurrences, offset, run.options.page_size, page.manifest.occurrence_count) &&
-        pageMatches(page.edges, offset, run.options.page_size, page.manifest.edge_count));
-};
-const sameSnapshotMetadata = (pages) => {
-    const first = pages[0];
-    return (first !== undefined &&
-        pages.every((page) => isDeepStrictEqual(page.manifest, first.manifest) &&
-            isDeepStrictEqual(page.limits, first.limits) &&
-            isDeepStrictEqual(page.provenance, first.provenance) &&
-            isDeepStrictEqual(page.integrity_contradictions, first.integrity_contradictions) &&
-            isDeepStrictEqual(page.limitations, first.limitations)));
-};
-const pageMatches = (page, offset, limit, total) => page.offset === offset &&
-    page.limit === limit &&
-    page.total === total &&
-    page.items.length === Math.max(0, Math.min(limit, page.total - offset)) &&
-    page.next_offset === (offset + limit < page.total ? offset + limit : null);
-const traversalLimits = (run) => ({
-    max_entries: run.options.max_entries,
-    max_total_bytes: run.options.max_total_bytes,
-    max_entry_bytes: run.options.max_entry_bytes,
-    max_compression_ratio: run.options.max_compression_ratio,
-    max_depth: run.options.max_depth,
-    max_path_bytes: run.options.max_path_bytes,
-});
-const targetMatches = (inventory, target) => inventory.manifest.root_sha256 === target.root_sha256 &&
-    inventory.manifest.graph_sha256 === target.graph_sha256 &&
-    inventory.manifest.manifest_id === target.manifest_id &&
-    inventory.manifest.root_format === target.format;
-const runLimitations = (left, right) => [
-    ...new Set([
-        ...left.result.inventory.limitations.map((item) => `Left: ${item}`),
-        ...right.result.inventory.limitations.map((item) => `Right: ${item}`),
-        AUTOMATIC_RUN_LIMITATION,
-    ]),
-].sort((first, second) => first.localeCompare(second));
-const evidenceFor = (workspace, evidenceId) => evidenceId === null
-    ? undefined
-    : workspace.bundle.records.find(({ evidence_id: current }) => current === evidenceId);
-const replayConflict = () => err(new InvestigationWorkspaceError("read", "revision-conflict"));
-const replayIntegrity = (message, cause) => err(new EvidenceIntegrityError(message, cause === undefined ? undefined : { cause }));

package/dist/application/DeferredFileAuthorization.js

@@ -1,61 +0,0 @@
-import { AnalysisProtocolError, PermissionRequiredError, } from "../domain/errors.js";
-import { err, ok } from "../domain/result.js";
-import { PermissionPathError, } from "./PermissionAuthority.js";
-/** Authorize one root-scoped operation and project policy path failures. */
-export const authorizeRootPermission = async (authority, request) => {
-    const authorized = await authority.authorize({
-        capability: request.capability,
-        roots: request.roots,
-        executables: [],
-        environment_names: [],
-        network: "none",
-        mount: false,
-        operation_identity: `${request.operation}:${request.capability}:${request.roots.join(":")}`,
-    }, request.access);
-    return authorized.ok
-        ? ok(null)
-        : err(authorized.error instanceof PermissionRequiredError
-            ? authorized.error
-            : new AnalysisProtocolError(authorized.error.message, {
-                cause: authorized.error,
-            }));
-};
-/** Authorize an existing file read and defer write authority until requested. */
-export const authorizeFileReadWithDeferredWrite = async (authority, input) => {
-    const read = await authority.authorize({
-        capability: input.readCapability,
-        roots: [input.path],
-        executables: [],
-        environment_names: [],
-        network: "none",
-        mount: false,
-        operation_identity: `${input.operation}:${input.readCapability}:${input.path}`,
-    }, "read");
-    let writeAuthorization;
-    if (!read.ok) {
-        if (!(read.error instanceof PermissionPathError) ||
-            read.error.reason !== "not_found")
-            return err(read.error instanceof PermissionRequiredError
-                ? read.error
-                : new AnalysisProtocolError(read.error.message, {
-                    cause: read.error,
-                }));
-        writeAuthorization = authorizeRootPermission(authority, {
-            capability: input.writeCapability,
-            roots: [input.path],
-            access: "write",
-            operation: input.operation,
-        });
-        const authorized = await writeAuthorization;
-        if (!authorized.ok)
-            return authorized;
-    }
-    return ok({
-        authorizeWrite: () => (writeAuthorization ??= authorizeRootPermission(authority, {
-            capability: input.writeCapability,
-            roots: [input.path],
-            access: "write",
-            operation: input.operation,
-        })),
-    });
-};

package/dist/application/DoctorProjection.js

@@ -1,43 +0,0 @@
-/** Project doctor diagnostics for concise CLI output or explicit full detail. */
-export const projectDoctorReport = (report, detail) => detail === "full" ? report : doctorSummary(report);
-const doctorSummary = (report) => ({
-    healthy: report.healthy,
-    environment_healthy: report.environment_healthy,
-    scope: report.scope,
-    ...(report.hopperPath === undefined
-        ? {}
-        : { hopper_path: report.hopperPath }),
-    providers: (report.providerInspections ?? []).map((provider) => ({
-        id: provider.id,
-        configured: provider.configured,
-        available: provider.available,
-        provider_version: provider.providerVersion,
-        failed_checks: provider.checks.filter(({ ok }) => !ok).map(checkSummary),
-    })),
-    failed_scope_checks: report.scope_checks
-        .filter(({ ok }) => !ok)
-        .map(checkSummary),
-    informational_drift_count: report.informational_checks.filter(({ ok }) => !ok)
-        .length,
-    identity: report.identity === undefined
-        ? null
-        : {
-            cli_package_version: report.identity.cli_package_version,
-            expected_skill_version: report.identity.expected_skill_version,
-            catalog: {
-                counts: report.identity.catalog.counts,
-                digests: report.identity.catalog.digests,
-            },
-            installations: report.identity.installations,
-            skill: report.identity.skill,
-            registrations: report.identity.registrations,
-        },
-});
-const checkSummary = (check) => ({
-    name: check.name,
-    classification: check.classification,
-    ...(check.detail === undefined ? {} : { detail: check.detail }),
-    ...(check.remediation === undefined || check.remediation === null
-        ? {}
-        : { remediation: check.remediation }),
-});