export type CanonicalTaskIntent = 'debug' | 'feature' | 'refactor' | 'understand' | 'review' | 'performance' | 'memory' | 'knowledge' | 'release' | 'verification' | 'unknown';
export interface CanonicalTaskRequest {
    requestId: string;
    turnId?: string;
    sessionId: string;
    executionId: string;
    projectRoot: string;
    host: string;
    command?: string;
    activeSkill?: string;
    query: string;
    intent: CanonicalTaskIntent;
    action: import('./memory.js').RetrievalTaskAction;
    classification?: {
        intentSource: 'semantic_override' | 'intent_parser';
        intentReason: string;
        actionReason: string;
        mutating: boolean;
    };
    requiredPolicyFacets: import('./memory.js').PolicyFacet[];
    entities: string[];
    symbols: string[];
    knowledgeNeeds: import('./knowledge.js').KnowledgeNeed[];
    targetAnchors: string[];
    projectVersions: Record<string, string>;
    tokenBudget: number;
    intentArtifactHash?: string;
    queryPlanHash?: string;
}
export type ContextFileRole = 'target' | 'caller' | 'dependency' | 'resource' | 'route' | 'test' | 'config';
export type ArtifactContextRole = 'operation_target' | 'supporting_file' | 'reference_pattern';
export interface SelectedEvidenceProvenance {
    sourceId: string;
    producer: string;
    producerVersion: string;
    parentRefs: string[];
}
export interface SelectedCodeFile {
    channel: 'code';
    stableRef: string;
    sourceRevision: string;
    contentHash: string;
    retrievalProfile?: string;
    generation?: number;
    rank: number;
    contributingLegs: Array<{
        leg: string;
        rank: number;
        score?: number;
    }>;
    excerpt: string;
    provenanceStatus: 'complete';
    provenance: SelectedEvidenceProvenance;
    path: string;
    role: ContextFileRole;
    /** Authoritative mutation role. */
    artifactRole: ArtifactContextRole;
    score: number;
    symbols: string[];
    evidence: string[];
    freshness?: {
        exists: boolean;
        indexed: boolean;
        current: boolean;
        indexedHash?: string;
        currentHash?: string;
        reason?: string;
    };
}
export interface SelectedMemoryEvidence {
    channel: 'memory';
    stableRef: string;
    sourceRevision: string;
    contentHash: string;
    retrievalProfile?: string;
    generation?: number;
    rank: number;
    contributingLegs: Array<{
        leg: string;
        rank: number;
        score?: number;
    }>;
    provenanceStatus: 'complete';
    provenance: SelectedEvidenceProvenance;
    id: string;
    title: string;
    excerpt: string;
    type: string;
    score: number;
    applicability: string[];
    evidenceStatus: 'verified' | 'unverified';
    scoreDetails?: import('./memory.js').MemoryScoreDetails;
}
export interface SelectedKnowledgeEvidence {
    channel: 'knowledge';
    stableRef: string;
    sourceRevision: string;
    contentHash: string;
    retrievalProfile?: string;
    generation?: number;
    rank: number;
    contributingLegs: Array<{
        leg: string;
        rank: number;
        score?: number;
    }>;
    provenanceStatus: 'complete';
    provenance: SelectedEvidenceProvenance;
    id: string;
    source: string;
    title: string;
    excerpt: string;
    url: string;
    version?: string;
    score: number;
    applicability: string[];
    scoreDetails?: import('./knowledge.js').KnowledgeScoreDetails;
}
export interface RetrievalQualitySummary {
    status: 'healthy' | 'insufficient';
    code: {
        selected: number;
        rejected: number;
        targetHashCurrent: boolean;
    };
    memory: {
        selected: number;
        rejected: number;
    };
    knowledge: {
        selected: number;
        rejected: number;
        compatibleSources: string[];
    };
}
export interface DirectedFollowup {
    kind: string;
    target?: string;
    reason: string;
}
export interface CanonicalAction {
    tool: string;
    projectedTool?: string;
    input: Record<string, unknown>;
    status: 'required' | 'recommended' | 'unsupported' | 'degraded';
    required: boolean;
    reason?: string;
    binding: {
        projectRoot: string;
        sessionId: string;
        executionId: string;
        requestId: string;
        turnId?: string;
        intentArtifactHash?: string;
        queryPlanHash?: string;
        domainActionPlanHash?: string;
        activeSkill?: string;
        targetAnchors: string[];
        requiredContextReceipt: string;
        requiredPolicyFacets: import('./memory.js').PolicyFacet[];
        operationMode?: 'create' | 'modify' | 'delete' | 'analyze' | 'debug' | 'format' | 'unknown';
        normalizedInputHash?: string;
        operationTargets?: Array<{
            path: string;
            expectedState: 'existing' | 'missing' | 'unknown';
            contentHash?: string;
        }>;
        safeInputVariations?: Record<string, {
            type: 'string' | 'number' | 'boolean';
            enum?: Array<string | number | boolean>;
            minimum?: number;
            maximum?: number;
            pattern?: string;
        }>;
    };
    verificationPlan: Array<{
        kind: 'formatter' | 'lint' | 'typecheck' | 'test' | 'build' | 'generated_files';
        required: boolean;
        policyFacet?: import('./memory.js').PolicyFacet;
        mode?: 'check' | 'write';
    }>;
    actionLease?: import('../action-lease.js').ActionLeaseV1;
}
export interface StructuredRetrievalWarning {
    category: string;
    reason: string;
}
export interface TaskContextEnvelope {
    request: CanonicalTaskRequest;
    code: {
        files: SelectedCodeFile[];
        symbols: string[];
        ambiguities?: Array<{
            symbol: string;
            reason: string;
            candidates: Array<{
                id: string;
                file: string;
                score: number;
                evidence: string[];
            }>;
        }>;
        budget?: {
            maxFiles: number;
            graphFileLimit: number;
            selectedGraphFiles: number;
        };
    };
    memory: {
        entries: SelectedMemoryEvidence[];
    };
    knowledge: {
        entries: SelectedKnowledgeEvidence[];
    };
    quality: RetrievalQualitySummary;
    allowedFollowups: DirectedFollowup[];
    canonicalNextAction?: CanonicalAction;
    warnings: StructuredRetrievalWarning[];
    modelRecommendation?: import('../model-recommendation.js').ModelRecommendation;
    receipt: {
        requestId: string;
        issuedAt: number;
        expiresAt: number;
        hash: string;
        contextHash: string;
        intentArtifactHash?: string;
        queryPlanHash?: string;
    };
    retrieval?: {
        sessionId: string;
        cycle: number;
        maxCycles: 3;
        state: 'open' | 'satisfied' | 'exhausted' | 'expired';
        gaps: import('./retrieval-session.js').RetrievalGap[];
        remainingTokenBudget: number;
        baselineReceipt: string;
    };
}
//# sourceMappingURL=task-context-envelope.d.ts.map