project-tiny-context-harness 0.11.0 → 0.12.0

package/dist/lib/long-task-finalization-identity.js

@@ -1,58 +0,0 @@
-import { captureStoredExternalConfirmationArtifactIdentities } from "./long-task-external-confirmation-artifacts.js";
-import { captureStoredExternalConfirmationChallengeIdentities } from "./long-task-external-confirmation-challenge.js";
-import { readStoredExternalConfirmationRecord } from "./long-task-external-confirmation-state.js";
-import { captureStoredExternalConfirmationRecordIdentities } from "./long-task-external-confirmation-state.js";
-import { captureProtectedAuthorityInputsIdentity } from "./long-task-freshness.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-export async function captureFinalizationIdentity(input) {
-    const confirmationRefs = input.compiled.global.acceptance.external_confirmations
-        .map((confirmation) => confirmation.key)
-        .sort();
-    const [protectedAuthorityInputs, externalRecords, externalChallenges, externalArtifacts,] = await Promise.all([
-        captureProtectedAuthorityInputsIdentity(input.compiled),
-        captureStoredExternalConfirmationRecordIdentities(input.repository, input.compiled.workdir, confirmationRefs),
-        captureStoredExternalConfirmationChallengeIdentities(input.repository, input.compiled.workdir, confirmationRefs),
-        captureExternalArtifactIdentities(input.repository, input.compiled.workdir, confirmationRefs),
-    ]);
-    return {
-        active_authority_identity: input.active.active_authority_identity,
-        authority_revision: input.active.authority_revision,
-        verifier_identity_sha256: input.compiled.verifier_identity.bundle_sha256,
-        candidate: {
-            git_head: input.candidate.git_head,
-            git_tree: input.candidate.git_tree,
-            workspace_fingerprint: typeof input.workspace_fingerprint === "string"
-                ? input.workspace_fingerprint
-                : input.workspace_fingerprint.identity,
-        },
-        compiled_identity: input.compiled.compiled_identity,
-        raw_contract_sha256: protectedAuthorityInputs.snapshot.raw_contract_sha256,
-        protected_authority_inputs_identity: protectedAuthorityInputs.identity,
-        external_records: externalRecords,
-        external_challenges: externalChallenges,
-        external_artifacts: externalArtifacts,
-    };
-}
-export function finalizationIdentityDigest(identity) {
-    return sha256Hex(canonicalValueJson(identity));
-}
-async function captureExternalArtifactIdentities(repository, workdir, confirmationRefs) {
-    const result = {};
-    for (const confirmationRef of confirmationRefs) {
-        const stored = await readStoredExternalConfirmationRecord(repository, workdir, confirmationRef);
-        if (stored.error)
-            throw new Error(`finalization_external_record_invalid:${confirmationRef}:${stored.error}`);
-        if (!stored.record ||
-            stored.record.schema_version !==
-                "long-task-external-confirmation-record-v2")
-            continue;
-        const identities = await captureStoredExternalConfirmationArtifactIdentities(repository, workdir, stored.record.artifact_snapshots);
-        for (const [storeRef, identity] of Object.entries(identities)) {
-            const previous = result[storeRef];
-            if (previous && previous !== identity)
-                throw new Error(`finalization_external_artifact_identity_conflict:${storeRef}`);
-            result[storeRef] = identity;
-        }
-    }
-    return Object.fromEntries(Object.entries(result).sort(([left], [right]) => left.localeCompare(right)));
-}

package/dist/lib/long-task-finding-context.d.ts

@@ -1,3 +0,0 @@
-import type { CheckExecutionResultV2, CompiledDeliveryContractV2, LongTaskFindingV2 } from "./long-task-delivery-types.js";
-export declare function enrichCheckResultFindings(compiled: CompiledDeliveryContractV2, result: CheckExecutionResultV2): CheckExecutionResultV2;
-export declare function enrichFinding(compiled: CompiledDeliveryContractV2, finding: LongTaskFindingV2, result?: CheckExecutionResultV2): LongTaskFindingV2;

package/dist/lib/long-task-finding-context.js

@@ -1,189 +0,0 @@
-import { resolveAcceptanceAssertion } from "./long-task-acceptance-reference.js";
-import { deriveMaterialSourceFragments } from "./long-task-source-fragments.js";
-export function enrichCheckResultFindings(compiled, result) {
-    return {
-        ...result,
-        findings: result.findings.map((finding) => enrichFinding(compiled, finding, result)),
-    };
-}
-export function enrichFinding(compiled, finding, result) {
-    const context = resolveFindingContext(compiled, finding);
-    const { check, outcome, sourceClaims, sourceTargets } = context;
-    const { authorities, expectations } = context;
-    const factRefs = unique([
-        ...(finding.fact_refs ?? []),
-        ...authorities.flatMap((authority) => authority.fact_ref ? [authority.fact_ref] : []),
-        ...expectations.map((expectation) => expectation.fact_ref),
-    ]);
-    const proofRefs = unique([
-        ...(finding.proof_obligation_refs ?? []),
-        ...authorities.map((authority) => authority.obligation_ref),
-        ...expectations.map((expectation) => expectation.proof_ref),
-    ]);
-    const expectedAuthorityRefs = unique([
-        ...(finding.expected_authority_refs ?? []),
-        ...(finding.assertion_key &&
-            check?.expected_authority_refs[finding.assertion_key]
-            ? [check.expected_authority_refs[finding.assertion_key]]
-            : []),
-    ]);
-    const actualEvidenceRefs = unique([
-        ...(finding.actual_evidence_refs ?? []),
-        ...(result ? [`execution:${result.execution_identity}`] : []),
-        ...Object.keys(result?.artifact_hashes ?? {}).map((artifact) => `artifact:${artifact}`),
-    ]);
-    const sourceFragmentRefs = unique([
-        ...(finding.source_fragment_refs ?? []),
-        ...fragmentsForSourceClaims(compiled, sourceClaims),
-    ]);
-    const rerunObligationRefs = unique([
-        ...(finding.rerun_obligation_refs ?? []),
-        ...proofRefs,
-        ...authorities.map((authority) => authority.obligation_ref),
-        ...normalizedClaimRefs(finding),
-    ]);
-    const enriched = {
-        ...finding,
-        invalidation_reasons: unique([
-            ...(finding.invalidation_reasons ?? []),
-            finding.code,
-        ]),
-    };
-    applyFindingReferences(enriched, {
-        sourceClaims,
-        sourceTargets,
-        sourceFragmentRefs,
-        factRefs,
-        proofRefs,
-        expectedAuthorityRefs,
-        actualEvidenceRefs,
-        rerunObligationRefs,
-    });
-    applyFindingOwners(enriched, outcome, check);
-    return enriched;
-}
-function resolveFindingContext(compiled, finding) {
-    const outcome = finding.outcome_key
-        ? (compiled.outcomes.find((item) => item.key === finding.outcome_key) ??
-            null)
-        : null;
-    const sourceClaims = sourceClaimsForFinding(compiled, finding);
-    const sourceTargets = unique(compiled.source_claims
-        .filter((source) => sourceClaims.includes(source.key))
-        .flatMap((source) => dispositionTargetRefs(source.disposition)));
-    const check = finding.check_key
-        ? (allChecks(compiled).find((item) => item.outcome_key === finding.outcome_key &&
-            item.key === finding.check_key) ?? null)
-        : null;
-    const authorities = check
-        ? check.observation_authorities.filter((authority) => !finding.assertion_key ||
-            authority.assertion_ref === finding.assertion_key)
-        : [];
-    const expectations = check
-        ? check.semantic_fact_expectations.filter((expectation) => !finding.assertion_key ||
-            expectation.assertion_ref === finding.assertion_key)
-        : [];
-    return {
-        outcome,
-        check,
-        sourceClaims,
-        sourceTargets,
-        authorities,
-        expectations,
-    };
-}
-function applyFindingReferences(finding, refs) {
-    if (refs.sourceClaims.length)
-        finding.source_claim_keys = refs.sourceClaims;
-    if (refs.sourceTargets.length)
-        finding.source_target_refs = refs.sourceTargets;
-    if (refs.sourceFragmentRefs.length)
-        finding.source_fragment_refs = refs.sourceFragmentRefs;
-    if (refs.factRefs.length)
-        finding.fact_refs = refs.factRefs;
-    if (refs.proofRefs.length)
-        finding.proof_obligation_refs = refs.proofRefs;
-    if (refs.expectedAuthorityRefs.length)
-        finding.expected_authority_refs = refs.expectedAuthorityRefs;
-    if (refs.actualEvidenceRefs.length)
-        finding.actual_evidence_refs = refs.actualEvidenceRefs;
-    if (refs.rerunObligationRefs.length)
-        finding.rerun_obligation_refs = refs.rerunObligationRefs;
-}
-function applyFindingOwners(finding, outcome, check) {
-    if (outcome && !finding.owner_paths)
-        finding.owner_paths = outcome.product.owner.path_globs;
-    if (outcome)
-        finding.implementation_owner = {
-            label: outcome.product.owner.label,
-            path_globs: [...outcome.product.owner.path_globs],
-        };
-    if (check)
-        finding.verification_owner = {
-            kind: "machine_check",
-            outcome_key: check.outcome_key,
-            check_key: check.key,
-            runner_target: check.runner.resolved_target,
-            input_paths: unique([...check.input_paths, ...check.verification_inputs]),
-        };
-}
-function allChecks(compiled) {
-    return [
-        ...compiled.global.acceptance.checks,
-        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-}
-function fragmentsForSourceClaims(compiled, sourceClaimKeys) {
-    const sourceClaims = compiled.source_claims.filter((claim) => sourceClaimKeys.includes(claim.key));
-    const items = compiled.source_items.filter((item) => sourceClaims.some((claim) => {
-        const [sourcePath, anchor] = claim.source_ref.split("#");
-        return (item.source_path === sourcePath &&
-            (item.key === claim.key || !anchor || item.key === anchor));
-    }));
-    return unique(items.flatMap((item) => deriveMaterialSourceFragments(item).map((fragment) => fragment.key)));
-}
-function normalizedClaimRefs(finding) {
-    return (finding.claim_keys ?? []).map((claim) => finding.outcome_key && !claim.startsWith(`${finding.outcome_key}.`)
-        ? `${finding.outcome_key}.${claim}`
-        : claim);
-}
-function unique(values) {
-    return [...new Set(values)].sort();
-}
-function dispositionTargetRefs(disposition) {
-    if (disposition.type === "outcome_result")
-        return [disposition.ref];
-    if (disposition.type === "claim" ||
-        disposition.type === "acceptance" ||
-        disposition.type === "global_constraint" ||
-        disposition.type === "risk_fact" ||
-        disposition.type === "external_confirmation")
-        return disposition.refs;
-    return [];
-}
-function sourceClaimsForFinding(compiled, finding) {
-    const acceptanceRef = finding.check_key && finding.assertion_key
-        ? `${finding.outcome_key ?? "GLOBAL"}.${finding.check_key}.${finding.assertion_key}`
-        : null;
-    const resolvedAcceptance = acceptanceRef
-        ? resolveAcceptanceAssertion(compiled, acceptanceRef)
-        : null;
-    const productRefs = new Set((finding.claim_keys ?? []).map((claim) => finding.outcome_key ? `${finding.outcome_key}.${claim}` : claim));
-    return compiled.source_claims
-        .filter((source) => {
-        if (source.disposition.type === "acceptance" &&
-            resolvedAcceptance &&
-            source.disposition.refs.includes(resolvedAcceptance.ref))
-            return true;
-        if (source.disposition.type === "claim" &&
-            source.disposition.refs.some((reference) => productRefs.has(reference)))
-            return true;
-        if (source.disposition.type === "outcome_result" &&
-            productRefs.has(source.disposition.ref))
-            return true;
-        return (source.disposition.type === "global_constraint" &&
-            source.disposition.refs.some((reference) => productRefs.has(reference)));
-    })
-        .map((source) => source.key)
-        .sort();
-}

package/dist/lib/long-task-freshness.d.ts

@@ -1,30 +0,0 @@
-import type { CompiledDeliveryContractV2, VerifierIdentityV2 } from "./long-task-delivery-types.js";
-import type { DesignAuthorityIdentityV1 } from "./design-authority-types.js";
-export interface ProtectedAuthorityInputsSnapshotV1 {
-    schema_version: "long-task-protected-authority-inputs-v1";
-    raw_contract_sha256: string;
-    contract_files: Record<string, string>;
-    source_files: Record<string, string>;
-    context: {
-        mode: "referenced" | "full";
-        topology_sha256: string;
-        files: string[];
-        file_sha256: Record<string, string>;
-    };
-    project_design_authority: DesignAuthorityIdentityV1 | null;
-    runner_frozen_files: Record<string, Record<string, string>>;
-    verification_inputs: Record<string, Record<string, string>>;
-    verifier_identity: VerifierIdentityV2;
-    external_public_keys: Record<string, {
-        key_id: string;
-        public_key_ref: string;
-        sha256: string;
-    }>;
-}
-export interface ProtectedAuthorityInputsIdentityV1 {
-    identity: string;
-    snapshot: ProtectedAuthorityInputsSnapshotV1;
-}
-export declare function captureProtectedAuthorityInputsIdentity(compiled: CompiledDeliveryContractV2): Promise<ProtectedAuthorityInputsIdentityV1>;
-export declare function deliveryCompileFreshness(compiled: CompiledDeliveryContractV2): Promise<string[]>;
-export declare function assertVerifierAuthorityCurrent(repositoryRoot: string, expected: VerifierIdentityV2): Promise<void>;

package/dist/lib/long-task-freshness.js

@@ -1,203 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { captureContextGraphSnapshot, captureContextGraphSnapshotWithPhysicalFiles, } from "./context-graph-snapshot.js";
-import { canonicalValueJson, sha256Hex } from "./strict-codec.js";
-import { captureVerifierIdentity } from "./long-task-verifier-identity.js";
-import { verifierAuthorityDiff } from "./long-task-verifier-authority.js";
-import { parseDeliveryContractBundle } from "./long-task-delivery-parser.js";
-import { assertProtectedRepositoryFile } from "./repository-path-safety.js";
-import { inspectDesignAuthorityClosure } from "./design-authority-closure.js";
-export async function captureProtectedAuthorityInputsIdentity(compiled) {
-    const repository = compiled.repository_root;
-    const checks = allChecks(compiled);
-    const fileHashCache = new Map();
-    const hashRepositoryFile = (relativeInput, label, absoluteInput) => {
-        const relative = relativeInput.replace(/\\/gu, "/");
-        const cacheKey = absoluteInput ?? relative;
-        const existing = fileHashCache.get(cacheKey);
-        if (existing)
-            return existing;
-        const captured = (async () => {
-            const file = await assertProtectedRepositoryFile(repository, absoluteInput ?? path.join(repository, ...relative.split("/")), label);
-            return sha256Hex(await readFile(file));
-        })();
-        fileHashCache.set(cacheKey, captured);
-        return captured;
-    };
-    const hashFiles = async (files, label, physicalFiles) => Object.fromEntries(await Promise.all([...new Set(files)]
-        .sort()
-        .map(async (file) => [
-        file,
-        await hashRepositoryFile(file, `${label}:${file}`, requiredPhysicalFile(physicalFiles, file)),
-    ])));
-    const contextCapture = await captureContextGraphSnapshotWithPhysicalFiles(repository, compiled.task.context_refs, compiled.context_snapshot.mode);
-    const context = contextCapture.snapshot;
-    const [contractFiles, sourceFiles, contextFiles, runnerFrozenFiles, verificationInputs, verifierIdentity, externalPublicKeys, projectDesignAuthority,] = await Promise.all([
-        hashFiles(Object.keys(compiled.contract_files), "protected_contract"),
-        hashFiles(Object.keys(compiled.source_hashes), "protected_source"),
-        hashFiles(context.files, "protected_context", contextCapture.physical_files),
-        captureCheckFileIdentities(checks, (check) => check.runner.frozen_files, hashFiles, "protected_runner"),
-        captureCheckFileIdentities(checks, (check) => check.verification_input_hashes, hashFiles, "protected_verification_input"),
-        captureVerifierIdentity(repository, compiled.verifier_identity.hook_sha256 !== "not-required"),
-        captureExternalPublicKeyIdentities(compiled, hashRepositoryFile),
-        captureCurrentProjectDesignAuthority(compiled),
-    ]);
-    const rawContractSha256 = contractFiles[compiled.contract_file] ??
-        (await hashRepositoryFile(compiled.contract_file, "protected_raw_contract"));
-    const snapshot = {
-        schema_version: "long-task-protected-authority-inputs-v1",
-        raw_contract_sha256: rawContractSha256,
-        contract_files: contractFiles,
-        source_files: sourceFiles,
-        context: {
-            mode: context.mode,
-            topology_sha256: context.topology_sha256,
-            files: context.files,
-            file_sha256: contextFiles,
-        },
-        project_design_authority: projectDesignAuthority,
-        runner_frozen_files: runnerFrozenFiles,
-        verification_inputs: verificationInputs,
-        verifier_identity: verifierIdentity,
-        external_public_keys: externalPublicKeys,
-    };
-    return {
-        identity: sha256Hex(canonicalValueJson(snapshot)),
-        snapshot,
-    };
-}
-function requiredPhysicalFile(physicalFiles, file) {
-    if (!physicalFiles)
-        return undefined;
-    const physical = physicalFiles.get(file);
-    if (!physical)
-        throw new Error(`protected_context_physical_file_missing:${file}`);
-    return physical;
-}
-export async function deliveryCompileFreshness(compiled) {
-    const findings = [];
-    if (compiled.project_design_authority)
-        try {
-            const current = await captureCurrentProjectDesignAuthority(compiled);
-            if (canonicalValueJson(current) !==
-                canonicalValueJson(compiled.project_design_authority))
-                findings.push("project_design_authority_changed_after_compile");
-        }
-        catch {
-            findings.push("project_design_authority_changed_after_compile");
-        }
-    try {
-        const currentContract = await parseDeliveryContractBundle(compiled.workdir, compiled.repository_root, { validate_structure: false });
-        if (sha256Hex(canonicalValueJson(currentContract.contract)) !==
-            compiled.contract_sha256)
-            findings.push(`contract_changed_after_compile:${compiled.contract_file}`);
-    }
-    catch {
-        findings.push(`contract_changed_after_compile:${compiled.contract_file}`);
-    }
-    for (const [file, hash] of Object.entries(compiled.contract_files))
-        await compareFile(path.join(compiled.repository_root, file), hash, `contract_changed_after_compile:${file}`, findings);
-    for (const [file, hash] of Object.entries(compiled.source_hashes))
-        await compareFile(path.join(compiled.repository_root, file), hash, `source_changed_after_compile:${file}`, findings);
-    try {
-        const current = await captureContextGraphSnapshot(compiled.repository_root, compiled.task.context_refs, compiled.context_snapshot.mode);
-        if (current.topology_sha256 !== compiled.context_snapshot.topology_sha256)
-            findings.push("context_changed_after_compile:topology");
-        if (canonicalValueJson(current.files) !==
-            canonicalValueJson(compiled.context_snapshot.files))
-            findings.push("context_changed_after_compile:file_set");
-        for (const [file, hash] of Object.entries(compiled.context_snapshot.sha256))
-            if (current.sha256[file] !== hash)
-                findings.push(`context_changed_after_compile:${file}`);
-    }
-    catch (error) {
-        findings.push(`context_changed_after_compile:${message(error)}`);
-    }
-    try {
-        const currentVerifier = await captureVerifierIdentity(compiled.repository_root, compiled.verifier_identity.hook_sha256 !== "not-required");
-        const verifierDiff = verifierAuthorityDiff(compiled.verifier_identity, currentVerifier);
-        if (verifierDiff.verifier_content_changed)
-            findings.push("verifier_changed_after_compile:bundle");
-        if (verifierDiff.verifier_runtime_locator_changed)
-            findings.push("verifier_changed_after_compile:runtime_locator");
-    }
-    catch {
-        findings.push("verifier_changed_after_compile:bundle");
-    }
-    const checks = allChecks(compiled);
-    for (const check of checks)
-        for (const [file, hash] of Object.entries(check.runner.frozen_files))
-            await compareFile(path.join(compiled.repository_root, file), hash, `runner_changed_after_compile:${check.internal_id}:${file}`, findings);
-    for (const check of checks)
-        for (const [file, hash] of Object.entries(check.verification_input_hashes))
-            await compareFile(path.join(compiled.repository_root, file), hash, `verification_input_changed_after_compile:${check.internal_id}:${file}`, findings);
-    for (const [confirmationRef, assurance] of Object.entries(compiled.external_confirmation_identity_assurances))
-        if (assurance.scheme === "ed25519")
-            await compareFile(path.join(compiled.repository_root, assurance.public_key_ref), assurance.public_key_sha256, `external_public_key_changed_after_compile:${confirmationRef}:${assurance.public_key_ref}`, findings);
-    return [...new Set(findings)].sort();
-}
-async function captureCurrentProjectDesignAuthority(compiled) {
-    if (!compiled.project_design_authority)
-        return null;
-    const inspection = await inspectDesignAuthorityClosure(compiled.repository_root);
-    if (inspection.status !== "valid" || !inspection.identity)
-        throw new Error("project_design_authority_invalid");
-    return inspection.identity;
-}
-export async function assertVerifierAuthorityCurrent(repositoryRoot, expected) {
-    let current;
-    try {
-        current = await captureVerifierIdentity(repositoryRoot, expected.hook_sha256 !== "not-required");
-    }
-    catch {
-        throw new Error("verifier_authority_migration_required");
-    }
-    const diff = verifierAuthorityDiff(expected, current);
-    if (diff.verifier_content_changed || diff.verifier_runtime_locator_changed)
-        throw new Error("verifier_authority_migration_required");
-}
-async function compareFile(file, expected, finding, findings) {
-    try {
-        if (sha256Hex(await readFile(file)) !== expected)
-            findings.push(finding);
-    }
-    catch {
-        findings.push(finding);
-    }
-}
-function allChecks(compiled) {
-    return [
-        ...compiled.global.acceptance.checks,
-        ...compiled.outcomes.flatMap((outcome) => outcome.acceptance.checks),
-    ];
-}
-async function captureCheckFileIdentities(checks, select, hashFiles, label) {
-    const rows = await Promise.all(checks.map(async (check) => [
-        check.internal_id,
-        await hashFiles(Object.keys(select(check)), `${label}:${check.internal_id}`),
-    ]));
-    if (new Set(rows.map(([checkRef]) => checkRef)).size !== rows.length)
-        throw new Error("protected_authority_check_identity_duplicated");
-    return Object.fromEntries(rows.sort(([left], [right]) => left.localeCompare(right)));
-}
-async function captureExternalPublicKeyIdentities(compiled, hashRepositoryFile) {
-    const rows = await Promise.all(Object.entries(compiled.external_confirmation_identity_assurances)
-        .filter(([, assurance]) => assurance.scheme === "ed25519")
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(async ([confirmationRef, assurance]) => {
-        if (assurance.scheme !== "ed25519")
-            throw new Error("protected_external_public_key_scheme_invalid");
-        return [
-            confirmationRef,
-            {
-                key_id: assurance.key_id,
-                public_key_ref: assurance.public_key_ref,
-                sha256: await hashRepositoryFile(assurance.public_key_ref, `protected_external_public_key:${confirmationRef}`),
-            },
-        ];
-    }));
-    return Object.fromEntries(rows);
-}
-function message(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/lib/long-task-hook-install.d.ts

@@ -1,26 +0,0 @@
-import { type Stats } from "node:fs";
-import type { SyncReport } from "./sync-engine.js";
-export declare const LONG_TASK_HOOK_TRUST_REVIEW_NOTICE = "Codex Hook review required: open /hooks and trust the current Tiny Context project Hook before relying on PreToolUse, SubagentStart, SessionStart or Stop behavior. Tiny Context cannot observe or persist Codex Hook trust.";
-export interface LongTaskHookFileOperations {
-    lstat(target: string): Promise<Stats>;
-    readFile(target: string, encoding: "utf8"): Promise<string>;
-    mkdir(target: string, options: {
-        recursive: true;
-    }): Promise<unknown>;
-    writeFile(target: string, content: string, options: {
-        flag: "wx";
-    }): Promise<void>;
-    rename(source: string, destination: string): Promise<void>;
-    rm(target: string, options: {
-        force: true;
-    }): Promise<void>;
-    randomId(): string;
-}
-export declare function installLongTaskHooks(projectRoot: string, report: SyncReport, fileOperations?: Partial<LongTaskHookFileOperations>): Promise<void>;
-export declare function uninstallLongTaskHooks(projectRoot: string, report: SyncReport, fileOperations?: Partial<LongTaskHookFileOperations>): Promise<void>;
-export declare function packageOwnedCommand(entry: string): string;
-export declare function removeManagedHookEntries(groups: unknown, currentPackageCommand?: string): {
-    groups: unknown[];
-    removed: number;
-};
-export declare function isManagedHookEntry(entry: unknown, currentPackageCommand?: string): boolean;