import { WebJobProgress } from "@xenosystem/web-context-client/progress";
declare const WEB_CONTEXT_TOOL_RESULT_SCHEMA: "xeno.web-context.tool-result.v1";
interface WebContextEvidenceProjection {
    evidenceId: string;
    requestId: string;
    sourceUrl: string;
    finalUrl?: string;
    citations: Array<{
        url: string;
        title?: string;
        artifactId?: string;
    }>;
}
interface WebContextToolResult {
    schemaVersion: typeof WEB_CONTEXT_TOOL_RESULT_SCHEMA;
    operation: "search" | "fetch";
    requestId: string;
    evidence: WebContextEvidenceProjection;
    job?: {
        jobId: string;
        state: string;
    };
    artifact?: {
        artifactId: string;
        mediaType: string;
        bytes: number;
    };
    jobProgress?: WebJobProgress;
}
interface ImageUrlBlock {
    type: "image_url";
    image_url: {
        url: string;
        detail?: "auto" | "low" | "high";
    };
}
interface ResourceContentBlock {
    type: "resource";
    uri?: string;
    mimeType?: string;
    text?: string;
    data?: string;
}
type ToolAssistantContentBlock = TextBlock | ImageUrlBlock | ResourceContentBlock;
type ToolOperationState = "registered" | "starting" | "running_foreground" | "running_background" | "waiting_for_input" | "stalled" | "verifying" | "completed" | "failed" | "timed_out" | "cancelled" | "orphaned";
type ToolCompletionPolicy = "await" | "observe" | "detach";
interface ExpectedOutputContract {
    path: string;
    kind?: "file" | "directory";
    nonEmpty?: boolean;
}
interface ToolEvidence {
    id: string;
    kind: "artifact" | "process" | "verification";
    status: "pending" | "verified" | "failed";
    path?: string;
    observedAt: string;
    operationId: string;
    detail?: Record<string, string | number | boolean | null>;
}
interface ToolOperationSnapshot {
    schemaVersion: 1;
    operationId: string;
    turnId: string;
    generation: number;
    toolCallId: string;
    toolName: string;
    ownerSessionId?: string;
    state: ToolOperationState;
    terminal: boolean;
    presentation: "foreground" | "background";
    completionPolicy: ToolCompletionPolicy;
    promotable: boolean;
    processId?: string;
    taskId?: string;
    displayName?: string;
    pid?: number;
    commandFingerprint?: string;
    outputPath?: string;
    startedAt: string;
    lastActivityAt: string;
    deadlineAt?: string;
    elapsedMs: number;
    idleMs: number;
    outputBytes: number;
    nextOffset: number;
    exitCode?: number | null;
    completionReason?: string;
    suggestedNextAction?: string;
    expectedOutputs?: ExpectedOutputContract[];
    evidence?: ToolEvidence[];
}
interface ToolResult {
    success: boolean;
    output: string;
    error?: string;
    errorCode?: string;
    errorDetails?: Record<string, unknown>;
    assistantContent?: ToolAssistantContentBlock[];
    assistantOnlyContent?: ToolAssistantContentBlock[];
    operation?: ToolOperationSnapshot;
    evidence?: ToolEvidence[];
    webContext?: WebContextToolResult;
    retryable?: boolean;
}
interface TextBlock {
    type: "text";
    text: string;
}
interface ToolUseBlock {
    type: "tool_use";
    id: string;
    name: string;
    input: Record<string, unknown>;
    provider_metadata?: Record<string, unknown>;
}
interface ToolResultBlock {
    type: "tool_result";
    tool_use_id: string;
    content: string;
    assistant_content?: ToolAssistantContentBlock[];
    assistant_only_content?: ToolAssistantContentBlock[];
    is_error?: boolean;
    operation?: ToolOperationSnapshot;
    evidence?: ToolEvidence[];
    web_context?: WebContextToolResult;
    retryable?: boolean;
}
type ContentBlock = TextBlock | ToolUseBlock;
interface DirectShellResultRecord {
    kind: "direct_shell_result";
    origin: "user_direct_shell";
    command: string;
    cwd: string;
    taskId: string;
    processId?: string;
    presentation: "foreground" | "background";
    status: "running" | "completed" | "failed" | "terminated";
    exitCode: number | null;
    completionReason?: "exit" | "timeout" | "terminated" | "output_limit" | "spawn_error";
    elapsedMs: number;
    output: string;
    outputBytes: number;
    outputTruncated: boolean;
    omittedChars?: number;
    recordedAt: string;
}
interface DirectShellMessageMetadata {
    source: "direct_shell";
    directShell: DirectShellResultRecord;
}
interface Message {
    id?: string;
    role: "user" | "assistant";
    content: string | ContentBlock[] | ToolResultBlock[];
    metadata?: DirectShellMessageMetadata;
}
interface ToolMiddlewareContext {
    readonly toolName: string;
    readonly toolCallId: string;
    input: Record<string, unknown>;
    readonly iteration: number;
    readonly traceId: string;
    readonly signal: AbortSignal;
    addGuidance(text: string): void;
}
type ToolMiddleware = (ctx: ToolMiddlewareContext, next: () => Promise<ToolResult>) => Promise<ToolResult>;
interface PromptSectionContext {
    readonly systemPrompt: string;
    readonly taskPrompt?: string;
    readonly iteration: number;
    readonly model: string;
}
interface PromptSectionProvider {
    name: string;
    order?: number;
    provide(ctx: PromptSectionContext): string | null | undefined;
}
type CompletionGuardStopReason = "end_turn" | "tool_use" | "max_tokens" | "stop_sequence" | "empty_response" | "progress_checkpoint";
interface CompletionGuardTurnStats {
    readonly iteration: number;
    readonly maxIterations: number;
    readonly toolCalls: number;
    readonly toolFailures: number;
    readonly failuresByTool: Readonly<Record<string, number>>;
}
interface CompletionGuardEvaluationContext {
    readonly finalText: string;
    readonly iteration: number;
    readonly maxIterations: number;
    readonly messages: Message[];
    readonly stopReason: CompletionGuardStopReason;
    readonly stats: CompletionGuardTurnStats;
}
type CompletionGuardDecision = {
    allow: true;
} | {
    allow: false;
    guidance: string;
    stop?: boolean;
};
interface CompletionGuard {
    name: string;
    order?: number;
    evaluate(ctx: CompletionGuardEvaluationContext): CompletionGuardDecision | null | undefined | Promise<CompletionGuardDecision | null | undefined>;
}
type ValidationAuthority = "official" | "project" | "user" | "self" | "smoke" | "syntax";
type ValidationOutcome = "pass" | "fail" | "unknown";
type CompletionDecisionAction = "complete" | "continue" | "incomplete";
interface FailureCluster {
    signature: string;
    title: string;
    count: number;
    firstIteration: number;
    lastIteration: number;
    latestExcerpt: string;
}
interface ValidationSignal {
    id: string;
    iteration: number;
    toolName: string;
    command?: string;
    authority: ValidationAuthority;
    outcome: ValidationOutcome;
    stale: boolean;
    workspaceRevision: number;
    summary: string;
    failureCount?: number;
    passCount?: number;
    clusters: FailureCluster[];
}
interface ContractLedgerSummary {
    projectLike: boolean;
    benchmarkMode: boolean;
    requiredOutputPaths: string[];
    requiredValidation: boolean;
}
interface ValidationLedgerSummary {
    latestSignal: ValidationSignal | null;
    latestAuthoritativeSignal: ValidationSignal | null;
    latestUnresolvedFailure: ValidationSignal | null;
    signals: ValidationSignal[];
}
interface ProgressLedgerSummary {
    toolCalls: number;
    validationRuns: number;
    workspaceRevision: number;
    repeatedFailureSignature: string | null;
    repeatedFailureCount: number;
    iterationsSinceLastValidation: number | null;
}
interface CompletionDecision {
    action: CompletionDecisionAction;
    finalStateVerified: boolean;
    reason: string;
    message: string;
    blocking: boolean;
    unresolvedFailures: FailureCluster[];
    latestAuthoritativeSignal: ValidationSignal | null;
}
interface ExecutionGovernanceSummary {
    contract: ContractLedgerSummary;
    validation: ValidationLedgerSummary;
    progress: ProgressLedgerSummary;
    completionDecision: CompletionDecision | null;
}
interface ExecutionGovernanceOptions {
    taskPrompt?: string;
    benchmarkMode?: boolean;
    requiredOutputPaths?: string[];
}
interface RecordToolResultInput {
    toolName: string;
    input: Record<string, unknown>;
    result: ToolResult;
    iteration: number;
}
declare function shouldEnableExecutionGovernance(options: ExecutionGovernanceOptions): boolean;
declare class ExecutionGovernance {
    private readonly contract;
    private readonly signals;
    private readonly clusters;
    private toolCalls;
    private workspaceRevision;
    private lastCompletionDecision;
    private lastValidationIteration;
    private lastEvaluatedIteration;
    constructor(options?: ExecutionGovernanceOptions);
    recordToolResult(input: RecordToolResultInput): ValidationSignal[];
    evaluateCompletion(args: {
        finalText: string;
        iteration: number;
        stopReason: string;
        messages?: Message[];
        maxIterations?: number;
    }): CompletionDecision;
    getSummary(): ExecutionGovernanceSummary;
    private getLatestSignal;
    private getLatestAuthoritativeSignal;
    private getLatestUnresolvedFailure;
    private getRepeatedFailure;
    private setDecision;
    private cloneSignal;
}
interface InteractiveTurnGovernanceOptions {
    maxWebSearches?: number;
    maxWebFetches?: number;
    maxTotalWebResearchCalls?: number;
    maxLocalInspectionCalls?: number;
}
interface InteractiveToolRecordInput {
    toolName: string;
    input: Record<string, unknown>;
    result: ToolResult;
    iteration: number;
}
interface InteractiveToolPreflightInput {
    toolName: string;
    input: Record<string, unknown>;
    iteration: number;
}
interface InteractiveCompletionInput {
    finalText: string;
    iteration: number;
    stopReason: string;
}
interface InteractiveGovernanceDecision {
    message: string;
    blocking: boolean;
}
declare function isExplicitResearchPrompt(taskPrompt: string): boolean;
declare function isSimpleInformationalPrompt(taskPrompt: string): boolean;
declare function resolveInteractiveTurnMaxIterations(taskPrompt: string, configuredMaxIterations: number): number;
declare class InteractiveTurnGovernance {
    private readonly taskPrompt;
    private readonly maxWebSearches;
    private readonly maxWebFetches;
    private readonly maxTotalWebResearchCalls;
    private readonly maxLocalInspectionCalls;
    private readonly simpleInformationalPrompt;
    private readonly explicitResearchPrompt;
    private readonly searchQueries;
    private readonly fetchedUrls;
    private readonly localInspectionRecords;
    private readonly localEvidence;
    private readonly webFetchEvidence;
    private readonly artifactEvidence;
    private readonly verificationRecords;
    private readonly pendingAwaitOperations;
    private readonly transcriptReadRanges;
    private webSearches;
    private webFetches;
    private localInspectionCalls;
    private mutationEpoch;
    constructor(taskPrompt: string, options?: InteractiveTurnGovernanceOptions);
    maybeBlockToolCall(input: InteractiveToolPreflightInput): ToolResult | null;
    recordToolResult(input: InteractiveToolRecordInput): void;
    evaluateCompletion(input: InteractiveCompletionInput): InteractiveGovernanceDecision | null;
    private evaluateWebResearchCompletion;
    private isLocalSetupQuestion;
    private totalWebResearchCalls;
    private isOfficialResearchQuestion;
    private isWebResearchQuestion;
    private successfulWebFetches;
    private failedSpeculativeWebFetches;
    private shouldStopOfficialResearch;
    private minimumOfficialEvidenceFetches;
    private fetchedSourceSummary;
    private blockedResult;
    private evaluateArtifactClaims;
    private findOverlappingTranscriptRead;
}
declare class InteractiveChatTurnGovernance {
    private active;
    private activePrompt;
    readonly promptSection: PromptSectionProvider;
    readonly toolMiddleware: ToolMiddleware;
    readonly completionGuard: CompletionGuard;
    beginTurn(taskPrompt: string): void;
    endTurn(): void;
}
declare function buildContractLedgerGuidance(userPrompt?: string): string;
type ProjectDomainKey = "ml_artifact" | "visual_artifact" | "structured_data" | "performance" | "compiler_emulator" | "service_vm" | "search_symbolic" | "security_sanitization" | "science_bio_numeric" | "binary_recovery" | "async_process";
interface ProjectDomainProfile {
    key: ProjectDomainKey;
    label: string;
    trigger: RegExp;
    verifierRequirements: string[];
    finalAuditItems: string[];
}
interface ProjectExecutionPhase {
    name: "inspect" | "baseline" | "implement" | "validate" | "finalize";
    budgetPercent: number;
    objective: string;
}
interface ProjectExecutionProfile {
    projectLike: boolean;
    hiddenVerifierLikely: boolean;
    requiredOutputs: string[];
    referencedPaths: string[];
    domains: ProjectDomainProfile[];
    phases: ProjectExecutionPhase[];
    verifierRequirements: string[];
    finalAuditItems: string[];
}
declare function buildProjectExecutionProfile(prompt?: string): ProjectExecutionProfile;
declare function buildProjectExecutionGuidance(prompt?: string): string;
declare function buildProjectBudgetFinalizationGuidance(prompt?: string): string;
interface BenchBashMiddlewareOptions {
    benchmarkMode?: boolean;
}
declare function createBenchBashMiddleware(options?: BenchBashMiddlewareOptions): ToolMiddleware;
interface GovernanceExtensionsOptions {
    taskPrompt: string;
    benchmarkMode?: boolean;
    requiredOutputPaths?: string[];
    interactiveTurnGovernance?: InteractiveTurnGovernanceOptions | false;
    executionGovernance?: boolean;
    promptGuidance?: boolean;
    onExecutionGovernanceUpdate?: (summary: ExecutionGovernanceSummary) => void | Promise<void>;
}
interface GovernanceExtensions {
    toolMiddleware: ToolMiddleware[];
    promptSections: PromptSectionProvider[];
    completionGuards: CompletionGuard[];
    getExecutionGovernanceSummary(): ExecutionGovernanceSummary | null;
}
declare function createGovernanceExtensions(options: GovernanceExtensionsOptions): GovernanceExtensions;
export { type BenchBashMiddlewareOptions, type CompletionDecision, ExecutionGovernance, type ExecutionGovernanceOptions, type ExecutionGovernanceSummary, type FailureCluster, type GovernanceExtensions, type GovernanceExtensionsOptions, InteractiveChatTurnGovernance, InteractiveTurnGovernance, type InteractiveTurnGovernanceOptions, type ProjectDomainProfile, type ProjectExecutionPhase, type ProjectExecutionProfile, type ValidationSignal, buildContractLedgerGuidance, buildProjectBudgetFinalizationGuidance, buildProjectExecutionGuidance, buildProjectExecutionProfile, createBenchBashMiddleware, createGovernanceExtensions, isExplicitResearchPrompt, isSimpleInformationalPrompt, resolveInteractiveTurnMaxIterations, shouldEnableExecutionGovernance };