@xenosystem/agent-sdk 0.8.12

package/dist/automation/index.d.cts

@@ -0,0 +1,878 @@
+declare const XENO_ARTIFACT_SCHEMA_VERSION: 1;
+type XenoJsonPrimitive = string | number | boolean | null;
+type XenoJsonValue = XenoJsonPrimitive | XenoJsonObject | XenoJsonValue[];
+interface XenoJsonObject {
+    [key: string]: XenoJsonValue;
+}
+type XenoArtifactKind = "plan" | "requirements" | "design" | "task-graph" | "patch" | "diff" | "file" | "document" | "diagram" | "screenshot" | "recording" | "browser-snapshot" | "test-report" | "review-report" | "security-report" | "performance-report" | "release-report" | "sbom" | "provenance" | "attestation" | `custom:${string}`;
+type XenoArtifactState = "draft" | "pending_review" | "approved" | "rejected" | "superseded" | "archived";
+type XenoArtifactSensitivity = "public" | "internal" | "confidential" | "restricted";
+interface XenoContentHash {
+    algorithm: "sha256" | `custom:${string}`;
+    value: string;
+}
+type XenoArtifactStorageReference = {
+    type: "inline";
+    text?: string;
+    base64?: string;
+} | {
+    type: "file";
+    path: string;
+} | {
+    type: "blob";
+    uri: string;
+} | {
+    type: "git";
+    commit: string;
+    path: string;
+    repositoryId?: string;
+} | {
+    type: "url";
+    url: string;
+    expiresAt?: string;
+} | {
+    type: "external";
+    provider: string;
+    locator: string;
+};
+interface XenoArtifactContent {
+    hash: XenoContentHash;
+    sizeBytes: number;
+    storage: XenoArtifactStorageReference;
+    encoding?: "utf8" | "base64" | "binary" | `custom:${string}`;
+    redactedPreview?: string;
+}
+interface XenoArtifactIdentity {
+    runId?: string;
+    sessionId?: string;
+    turnId?: string;
+    taskId?: string;
+    agentId?: string;
+    workspaceId?: string;
+    repositoryId?: string;
+}
+type XenoArtifactActorKind = "agent" | "tool" | "user" | "system" | "integration";
+interface XenoArtifactActor {
+    kind: XenoArtifactActorKind;
+    id: string;
+    displayName?: string;
+    profileFingerprint?: string;
+}
+interface XenoArtifactProvenance {
+    producer: XenoArtifactActor;
+    eventId?: string;
+    toolCallId?: string;
+    operationId?: string;
+    executionContractFingerprint?: string;
+    capabilityLeaseIds?: string[];
+    sourceArtifactIds?: string[];
+    attributes?: XenoJsonObject;
+}
+type XenoEvidenceNodeType = "requirement" | "design-decision" | "risk" | "task" | "agent" | "run" | "tool-call" | "edit" | "commit" | "test-case" | "test-run" | "finding" | "approval" | "artifact" | "release" | "claim" | `custom:${string}`;
+type XenoEvidenceEdgeType = "decomposes" | "depends_on" | "implements" | "changes" | "tests" | "verifies" | "finds" | "fixes" | "reviews" | "approves" | "rejects" | "supersedes" | "derived_from" | "produced_by" | "supports_claim" | "contradicts_claim" | "released_as" | `custom:${string}`;
+interface XenoEvidenceReference {
+    type: XenoEvidenceNodeType;
+    id: string;
+    revision?: number;
+}
+interface XenoArtifactRelationship {
+    relation: XenoEvidenceEdgeType;
+    target: XenoEvidenceReference;
+    description?: string;
+    attributes?: XenoJsonObject;
+}
+type XenoArtifactAnchor = {
+    kind: "file";
+    path: string;
+    repositoryId?: string;
+    commit?: string;
+} | {
+    kind: "source-line";
+    path: string;
+    startLine: number;
+    endLine?: number;
+    repositoryId?: string;
+    commit?: string;
+} | {
+    kind: "diff-hunk";
+    path: string;
+    hunkId: string;
+    artifactId?: string;
+    revision?: number;
+} | {
+    kind: "symbol";
+    path: string;
+    symbol: string;
+    repositoryId?: string;
+    commit?: string;
+} | {
+    kind: "dom-node";
+    pageId: string;
+    selector?: string;
+    accessibilityId?: string;
+    snapshotArtifactId?: string;
+} | {
+    kind: "timeline";
+    startMs: number;
+    endMs?: number;
+    recordingArtifactId: string;
+} | {
+    kind: "region";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    mediaArtifactId: string;
+} | {
+    kind: "artifact";
+    artifactId: string;
+    revision?: number;
+} | {
+    kind: `custom:${string}`;
+    data: XenoJsonObject;
+};
+interface XenoArtifactRetention {
+    policyId?: string;
+    retainUntil?: string;
+    legalHold?: boolean;
+}
+interface XenoArtifactEnvelope {
+    schemaVersion: typeof XENO_ARTIFACT_SCHEMA_VERSION;
+    artifactId: string;
+    revision: number;
+    kind: XenoArtifactKind;
+    title: string;
+    description?: string;
+    state: XenoArtifactState;
+    createdAt: string;
+    updatedAt?: string;
+    mediaType: string;
+    sensitivity: XenoArtifactSensitivity;
+    identity?: XenoArtifactIdentity;
+    content: XenoArtifactContent;
+    provenance: XenoArtifactProvenance;
+    relationships?: XenoArtifactRelationship[];
+    anchors?: XenoArtifactAnchor[];
+    predecessorRevision?: number;
+    accessPolicyId?: string;
+    retention?: XenoArtifactRetention;
+    extensions?: Record<string, XenoJsonValue>;
+}
+interface XenoArtifactLifecycleEvent {
+    schemaVersion: typeof XENO_ARTIFACT_SCHEMA_VERSION;
+    eventId: string;
+    artifactId: string;
+    revision: number;
+    sequence: number;
+    recordedAt: string;
+    actor: XenoArtifactActor;
+    fromState: XenoArtifactState | null;
+    toState: XenoArtifactState;
+    reason?: string;
+    reviewEventId?: string;
+}
+type XenoArtifactReviewDecision = "approved" | "rejected" | "changes_requested";
+interface XenoArtifactReviewEventBase {
+    schemaVersion: typeof XENO_ARTIFACT_SCHEMA_VERSION;
+    eventId: string;
+    artifactId: string;
+    artifactRevision: number;
+    artifactHash: XenoContentHash;
+    sequence: number;
+    recordedAt: string;
+    actor: XenoArtifactActor;
+}
+type XenoArtifactReviewEvent = (XenoArtifactReviewEventBase & {
+    type: "review-requested";
+    reviewerIds?: string[];
+    message?: string;
+}) | (XenoArtifactReviewEventBase & {
+    type: "comment-added";
+    commentId: string;
+    body: string;
+    anchor?: XenoArtifactAnchor;
+    parentCommentId?: string;
+}) | (XenoArtifactReviewEventBase & {
+    type: "comment-resolved" | "comment-reopened";
+    commentId: string;
+    reason?: string;
+}) | (XenoArtifactReviewEventBase & {
+    type: "decision-recorded";
+    decision: XenoArtifactReviewDecision;
+    rationale?: string;
+    scope?: XenoArtifactAnchor;
+}) | (XenoArtifactReviewEventBase & {
+    type: "review-withdrawn";
+    reason?: string;
+});
+type XenoArtifactReviewEventInput = Omit<Extract<XenoArtifactReviewEvent, {
+    type: "review-requested";
+}>, "schemaVersion" | "eventId" | "sequence" | "recordedAt"> | Omit<Extract<XenoArtifactReviewEvent, {
+    type: "comment-added";
+}>, "schemaVersion" | "eventId" | "sequence" | "recordedAt"> | Omit<Extract<XenoArtifactReviewEvent, {
+    type: "comment-resolved" | "comment-reopened";
+}>, "schemaVersion" | "eventId" | "sequence" | "recordedAt"> | Omit<Extract<XenoArtifactReviewEvent, {
+    type: "decision-recorded";
+}>, "schemaVersion" | "eventId" | "sequence" | "recordedAt"> | Omit<Extract<XenoArtifactReviewEvent, {
+    type: "review-withdrawn";
+}>, "schemaVersion" | "eventId" | "sequence" | "recordedAt">;
+interface XenoArtifactReviewSummary {
+    status: "not_requested" | "pending" | "approved" | "rejected" | "changes_requested" | "withdrawn";
+    totalComments: number;
+    unresolvedComments: number;
+    latestDecision?: XenoArtifactReviewDecision;
+    latestDecisionEventId?: string;
+    scopedDecisionCount?: number;
+    lastReviewedAt?: string;
+}
+interface XenoArtifactRecord {
+    artifact: XenoArtifactEnvelope;
+    recordVersion: number;
+    etag: string;
+    lifecycleEvents: XenoArtifactLifecycleEvent[];
+    reviewEvents: XenoArtifactReviewEvent[];
+    reviewSummary: XenoArtifactReviewSummary;
+}
+interface XenoArtifactListQuery {
+    artifactIds?: string[];
+    kinds?: XenoArtifactKind[];
+    states?: XenoArtifactState[];
+    runId?: string;
+    sessionId?: string;
+    turnId?: string;
+    taskId?: string;
+    workspaceId?: string;
+    repositoryId?: string;
+    producerId?: string;
+    sensitivity?: XenoArtifactSensitivity[];
+    includeSuperseded?: boolean;
+}
+type AgentProfileExternalAction = "publish" | "deploy" | "push" | "send" | "purchase" | "sign" | "file-legal" | "change-infrastructure";
+type AgentProfileActionDecision = "allow" | "ask" | "deny";
+declare const XENO_CAPABILITY_LEASE_SCHEMA_VERSION: 1;
+type XenoCapabilityKind = "filesystem-read" | "filesystem-write" | "process-execute" | "network-connect" | "secret-use" | "external-action" | "browser-read" | "browser-act" | "computer-observe" | "computer-act" | "tool-invoke" | `custom:${string}`;
+type XenoCapabilityEffect = "read" | "write" | "execute" | "external";
+type XenoCapabilityLeaseState = "requested" | "active" | "denied" | "revoked" | "expired" | "exhausted";
+interface XenoCapabilitySubject {
+    runId: string;
+    agentId: string;
+    turnId?: string;
+    toolName?: string;
+    operationId?: string;
+}
+interface XenoCapabilityScope {
+    kind: XenoCapabilityKind;
+    effect: XenoCapabilityEffect;
+    operations: string[];
+    resources?: string[];
+    destinations?: string[];
+    secretIds?: string[];
+    externalAction?: AgentProfileExternalAction;
+    governingToolName?: string;
+}
+interface XenoCapabilityLeaseApprovalContext {
+    turnId?: string;
+    surface: "cli" | "hub" | "ide" | "api" | "hosted" | `custom:${string}`;
+    promptHash?: string;
+    messageId?: string;
+}
+interface XenoCapabilityLease {
+    schemaVersion: typeof XENO_CAPABILITY_LEASE_SCHEMA_VERSION;
+    leaseId: string;
+    version: number;
+    state: XenoCapabilityLeaseState;
+    subject: XenoCapabilitySubject;
+    scope: XenoCapabilityScope;
+    reason: string;
+    requestedAt: string;
+    requestExpiresAt: string;
+    durationMs: number;
+    activatedAt?: string;
+    expiresAt?: string;
+    expiredAt?: string;
+    deniedAt?: string;
+    revokedAt?: string;
+    exhaustedAt?: string;
+    maxUses: number;
+    useCount: number;
+    childInheritance: "none" | "explicit";
+    approvalRequirement: "principal" | "current-turn";
+    requestedBy: XenoArtifactActor;
+    approvedBy?: XenoArtifactActor;
+    deniedBy?: XenoArtifactActor;
+    revokedBy?: XenoArtifactActor;
+    approvalContext?: XenoCapabilityLeaseApprovalContext;
+    profileFingerprint: string;
+    policyFingerprints: string[];
+    auditEventIds?: string[];
+    evidenceArtifactIds?: string[];
+}
+interface XenoCapabilityUse {
+    subject: XenoCapabilitySubject;
+    kind: XenoCapabilityKind;
+    operation: string;
+    resource?: string;
+    destination?: string;
+    secretId?: string;
+    externalAction?: AgentProfileExternalAction;
+}
+interface ToolDefinition {
+    name: string;
+    description: string;
+    input_schema: {
+        type: "object";
+        properties: Record<string, unknown>;
+        required?: string[];
+        additionalProperties?: boolean | Record<string, unknown>;
+        [keyword: string]: unknown;
+    };
+}
+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;
+    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 ToolProgressUpdate {
+    activity?: "stdout" | "stderr" | "input" | "waiting_for_input" | "heartbeat" | "state";
+    message?: string;
+    bytes?: number;
+    outputBytes?: number;
+    nextOffset?: number;
+}
+interface ToolAuthorizationReceipt {
+    turnId: string;
+    toolCallId: string;
+    toolName: string;
+    iteration: number;
+    policy: {
+        allowed: true;
+        reason: string;
+        temporaryOverride: boolean;
+    };
+    permission: {
+        allowed: true;
+        reason: string;
+    };
+}
+interface ToolResult {
+    success: boolean;
+    output: string;
+    error?: string;
+    errorCode?: string;
+    errorDetails?: Record<string, unknown>;
+    assistantContent?: ToolAssistantContentBlock[];
+    assistantOnlyContent?: ToolAssistantContentBlock[];
+    operation?: ToolOperationSnapshot;
+    evidence?: ToolEvidence[];
+    retryable?: boolean;
+}
+interface ToolExecutionContext {
+    signal?: AbortSignal;
+    operationId?: string;
+    reportProgress?: (event: ToolProgressUpdate) => void;
+    authorization?: ToolAuthorizationReceipt;
+}
+type ToolExecutor = (input: Record<string, unknown>, context?: ToolExecutionContext) => Promise<ToolResult>;
+interface ToolPolicyProjection {
+    observabilityInput: Record<string, unknown>;
+    permissionInput: Record<string, unknown>;
+    permissionPreview?: string;
+    approvalKey?: string;
+    riskLevel?: "low" | "medium" | "high";
+}
+interface RegisteredTool {
+    definition: ToolDefinition;
+    execute: ToolExecutor;
+    projectPolicyInput?: (input: Record<string, unknown>) => ToolPolicyProjection | {
+        error: ToolResult;
+    };
+}
+interface TextBlock {
+    type: "text";
+    text: string;
+}
+type ExecutionSecurityLevel = "policy-only" | "process-hardened" | "contained";
+type ExecutionTrustMode = "trusted-workspace" | "untrusted";
+interface ExecutionSecurityCapabilities {
+    policyEnforcement: boolean;
+    restrictedIdentity: boolean;
+    lowIntegrity: boolean;
+    processTreeControl: boolean;
+    filesystemIsolation: boolean;
+    networkIsolation: boolean;
+    inheritedHandleAllowlist: boolean;
+    environmentSanitization: boolean;
+}
+declare const XENO_SECURE_EXECUTION_CONTRACT_SCHEMA_VERSION: 1;
+type XenoExecutionEnforcement = "none" | "policy" | "os";
+interface XenoExecutionIdentity {
+    runId: string;
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    taskId?: string;
+    workspaceId?: string;
+}
+interface XenoFilesystemExecutionPolicy {
+    enforcement: XenoExecutionEnforcement;
+    readRoots: string[];
+    writeRoots: string[];
+    executeRoots: string[];
+    deniedRoots: string[];
+}
+interface XenoNetworkDestination {
+    scheme?: "http" | "https" | "ws" | "wss" | "tcp" | `custom:${string}`;
+    host: string;
+    port?: number;
+}
+interface XenoNetworkExecutionPolicy {
+    enforcement: XenoExecutionEnforcement;
+    default: "deny" | "allow";
+    allowDestinations: XenoNetworkDestination[];
+    denyDestinations: XenoNetworkDestination[];
+    dns: "disabled" | "system" | "proxy-only";
+    proxyUrl?: string;
+    downloads: "deny" | "prompt" | "allow";
+    acknowledgedUnrestricted: boolean;
+}
+interface XenoProcessExecutionPolicy {
+    processTreeControl: boolean;
+    cleanup: "kill-tree" | "best-effort";
+    inheritedHandleAllowlist: boolean;
+    maximumProcesses?: number;
+    maximumMemoryBytes?: number;
+    maximumCpuTimeMs?: number;
+}
+interface XenoEnvironmentExecutionPolicy {
+    inheritance: "none" | "allowlist";
+    allowedKeys: string[];
+    deniedKeys: string[];
+}
+interface XenoSecretProjection {
+    secretId: string;
+    target: "environment" | "file" | "stdin" | "broker";
+    targetName?: string;
+}
+interface XenoExternalActionExecutionPolicy {
+    default: AgentProfileActionDecision;
+    overrides: Partial<Record<AgentProfileExternalAction, AgentProfileActionDecision>>;
+    requireCurrentTurnApproval: AgentProfileExternalAction[];
+    requireCapabilityLease: true;
+}
+interface XenoBrowserExecutionPolicy {
+    mode: "none" | "read" | "act";
+    profile: "ephemeral" | "isolated-persistent";
+    allowedDomains: string[];
+    readAllowedDomains: string[];
+    actAllowedDomains: string[];
+    deniedDomains: string[];
+    allowedSchemes: Array<"http" | "https">;
+    allowedPorts: number[];
+    redirectPolicy: "deny" | "same-origin" | "policy";
+    allowLoopbackDevelopment: boolean;
+    downloads: "deny" | "prompt" | "allow";
+    uploads: "deny" | "prompt" | "allow";
+    recording: "disabled" | "bounded";
+}
+interface XenoComputerExecutionPolicy {
+    mode: "none" | "observe" | "act";
+    allowedApplications: string[];
+    sensitiveRegionRedaction: boolean;
+    humanStopRequired: boolean;
+}
+interface XenoExecutionAdapterIdentity {
+    id: string;
+    version: string;
+    platform: NodeJS.Platform | string;
+    architecture: string;
+    certified: boolean;
+    certificationArtifactId?: string;
+    capabilities: ExecutionSecurityCapabilities;
+    limitations: string[];
+}
+interface XenoSecureExecutionContract {
+    schemaVersion: typeof XENO_SECURE_EXECUTION_CONTRACT_SCHEMA_VERSION;
+    contractId: string;
+    fingerprint: string;
+    createdAt: string;
+    expiresAt?: string;
+    identity: XenoExecutionIdentity;
+    requestedLevel: ExecutionSecurityLevel;
+    effectiveLevel: ExecutionSecurityLevel;
+    trustMode: ExecutionTrustMode;
+    profile: {
+        id: string;
+        version: string;
+        fingerprint: string;
+        permissionProfile: string;
+    };
+    filesystem: XenoFilesystemExecutionPolicy;
+    network: XenoNetworkExecutionPolicy;
+    process: XenoProcessExecutionPolicy;
+    environment: XenoEnvironmentExecutionPolicy;
+    secrets: XenoSecretProjection[];
+    externalActions: XenoExternalActionExecutionPolicy;
+    browser: XenoBrowserExecutionPolicy;
+    computer: XenoComputerExecutionPolicy;
+    capabilityLeaseIds: string[];
+    adapter: XenoExecutionAdapterIdentity;
+    auditEventIds?: string[];
+}
+declare const XENO_AUTOMATION_PROTOCOL_VERSION: 1;
+type XenoAutomationSurface = "browser" | "computer";
+type XenoAutomationEffect = "observe" | "act";
+type XenoBrowserAutomationOperation = "browser.navigate" | "browser.back" | "browser.forward" | "browser.reload" | "browser.wait" | "browser.snapshot" | "browser.screenshot" | "browser.locate" | "browser.click" | "browser.type" | "browser.key" | "browser.select" | "browser.scroll" | "browser.tabs.list" | "browser.tabs.open" | "browser.tabs.close" | "browser.console.read" | "browser.network.read" | "browser.storage.read" | "browser.page-errors.read" | "browser.upload" | "browser.download" | "browser.record.start" | "browser.record.stop";
+type XenoComputerAutomationOperation = "computer.observe" | "computer.screenshot" | "computer.window-state" | "computer.point" | "computer.click" | "computer.double-click" | "computer.right-click" | "computer.drag" | "computer.type" | "computer.key" | "computer.scroll" | "computer.wait" | "computer.launch";
+type XenoAutomationOperation = XenoBrowserAutomationOperation | XenoComputerAutomationOperation;
+interface XenoAutomationIdentity {
+    runId: string;
+    agentId: string;
+    sessionId?: string;
+    turnId?: string;
+    taskId?: string;
+    workspaceId?: string;
+}
+interface XenoAutomationTarget {
+    url?: string;
+    origin?: string;
+    domain?: string;
+    port?: number;
+    tabId?: string;
+    pageId?: string;
+    deviceId?: string;
+    applicationId?: string;
+    displayId?: string;
+    resource?: string;
+}
+interface XenoAutomationEvidencePolicy {
+    before: "required" | "optional" | "disabled";
+    after: "required" | "optional" | "disabled";
+    recording: "required" | "optional" | "disabled";
+    sensitivity: XenoArtifactSensitivity;
+    retainUntil?: string;
+    legalHold?: boolean;
+}
+interface XenoAutomationRequest {
+    protocolVersion: typeof XENO_AUTOMATION_PROTOCOL_VERSION;
+    operationId: string;
+    idempotencyKey: string;
+    requestedAt: string;
+    identity: XenoAutomationIdentity;
+    governingToolName: string;
+    operation: XenoAutomationOperation;
+    parameters: XenoJsonObject;
+    declaredTarget?: XenoAutomationTarget;
+    executionContract: XenoSecureExecutionContract;
+    capabilityLeaseId: string;
+    expectedLeaseVersion: number;
+    evidencePolicy?: Partial<XenoAutomationEvidencePolicy>;
+}
+interface XenoAutomationAdapterManifest {
+    protocolVersion: typeof XENO_AUTOMATION_PROTOCOL_VERSION;
+    adapterId: string;
+    adapterVersion: string;
+    platform: string;
+    architecture: string;
+    operations: XenoAutomationOperation[];
+    targetBinding: "atomic-preflight";
+    profileIsolation: "none" | "ephemeral" | "isolated-persistent" | "both";
+    supports: {
+        accessibilitySnapshots: boolean;
+        screenshots: boolean;
+        recordings: boolean;
+        consoleInspection: boolean;
+        networkInspection: boolean;
+        storageInspection: boolean;
+        pageErrorInspection: boolean;
+        visibleCoControl: boolean;
+        deterministicHandback: boolean;
+        immediateStop: boolean;
+        sensitiveRegionRedaction: boolean;
+    };
+    policyEnforcement: {
+        domain: boolean;
+        scheme: boolean;
+        port: boolean;
+        redirect: boolean;
+        upload: boolean;
+        download: boolean;
+    };
+    certified: boolean;
+    certificationArtifactId?: string;
+    limitations: string[];
+}
+type XenoAutomationEvidencePhase = "before" | "action" | "after" | "recording" | "diagnostic";
+type XenoAutomationEvidenceContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "base64";
+    base64: string;
+} | {
+    type: "reference";
+    storage: Exclude<XenoArtifactStorageReference, {
+        type: "inline";
+    }>;
+    hash: XenoArtifactContent["hash"];
+    sizeBytes: number;
+    encoding?: XenoArtifactContent["encoding"];
+};
+interface XenoAutomationEvidenceInput {
+    evidenceId: string;
+    phase: XenoAutomationEvidencePhase;
+    kind: Extract<XenoArtifactKind, "screenshot" | "recording" | "browser-snapshot" | "security-report" | "attestation"> | `custom:${string}`;
+    title: string;
+    description?: string;
+    mediaType: string;
+    content: XenoAutomationEvidenceContent;
+    sensitivity?: XenoArtifactSensitivity;
+    redactedPreview?: string;
+    anchors?: XenoArtifactEnvelope["anchors"];
+    extensions?: Record<string, XenoJsonValue>;
+}
+interface XenoAutomationPreflight {
+    token: string;
+    preparedAt: string;
+    expiresAt: string;
+    observedTarget: XenoAutomationTarget;
+    evidence?: XenoAutomationEvidenceInput[];
+    adapterState?: XenoJsonObject;
+}
+interface XenoAutomationExecutionGrant {
+    contractFingerprint: string;
+    lease: XenoCapabilityLease;
+    capabilityUse: XenoCapabilityUse;
+}
+interface XenoAutomationAdapterExecutionResult {
+    status: "ok" | "denied" | "cancelled" | "error";
+    startedAt: string;
+    completedAt: string;
+    observedTarget: XenoAutomationTarget;
+    data?: XenoJsonValue;
+    evidence?: XenoAutomationEvidenceInput[];
+    error?: {
+        code: string;
+        message: string;
+        retryable?: boolean;
+    };
+}
+interface XenoAutomationAdapter {
+    manifest(): Promise<XenoAutomationAdapterManifest> | XenoAutomationAdapterManifest;
+    preflight(request: XenoAutomationRequest, signal: AbortSignal): Promise<XenoAutomationPreflight>;
+    execute(request: XenoAutomationRequest, preflight: XenoAutomationPreflight, grant: XenoAutomationExecutionGrant, signal: AbortSignal): Promise<XenoAutomationAdapterExecutionResult>;
+    stop?(operationId: string, reason: string): Promise<void>;
+}
+interface XenoAutomationLeaseAuthority {
+    consume(leaseId: string, expectedVersion: number, use: XenoCapabilityUse): Promise<XenoCapabilityLease> | XenoCapabilityLease;
+}
+interface XenoAutomationExecutionResult {
+    operationId: string;
+    status: "ok" | "denied" | "cancelled" | "error" | "evidence-incomplete";
+    effect: XenoAutomationEffect;
+    startedAt: string;
+    completedAt: string;
+    adapter: Pick<XenoAutomationAdapterManifest, "adapterId" | "adapterVersion" | "platform" | "architecture">;
+    target: XenoAutomationTarget;
+    data?: XenoJsonValue;
+    artifacts: XenoArtifactEnvelope[];
+    lease: {
+        leaseId: string;
+        version: number;
+        state: XenoCapabilityLease["state"];
+        useCount: number;
+    };
+    error?: {
+        code: string;
+        message: string;
+        retryable?: boolean;
+    };
+}
+interface XenoAutomationConformanceCheck {
+    id: string;
+    status: "pass" | "fail";
+    message: string;
+}
+interface XenoAutomationConformanceReport {
+    protocolVersion: typeof XENO_AUTOMATION_PROTOCOL_VERSION;
+    adapter: Pick<XenoAutomationAdapterManifest, "adapterId" | "adapterVersion" | "platform" | "architecture">;
+    generatedAt: string;
+    passed: boolean;
+    checks: XenoAutomationConformanceCheck[];
+}
+interface XenoAutomationOperationDescriptor {
+    operation: XenoAutomationOperation;
+    surface: XenoAutomationSurface;
+    effect: XenoAutomationEffect;
+    evidence: Pick<XenoAutomationEvidencePolicy, "before" | "after" | "recording">;
+}
+declare const XENO_AUTOMATION_OPERATIONS: readonly XenoAutomationOperation[];
+declare function describeXenoAutomationOperation(operation: XenoAutomationOperation): XenoAutomationOperationDescriptor;
+declare function isXenoAutomationOperation(value: string): value is XenoAutomationOperation;
+type XenoAutomationErrorCode = "AUTOMATION_REQUEST_INVALID" | "AUTOMATION_CONTRACT_INVALID" | "AUTOMATION_CONTRACT_EXPIRED" | "AUTOMATION_IDENTITY_MISMATCH" | "AUTOMATION_OPERATION_UNSUPPORTED" | "AUTOMATION_POLICY_DENIED" | "AUTOMATION_TARGET_CHANGED" | "AUTOMATION_PREFLIGHT_INVALID" | "AUTOMATION_EVIDENCE_REQUIRED" | "AUTOMATION_EVIDENCE_INVALID" | "AUTOMATION_EVIDENCE_PERSISTENCE_FAILED" | "AUTOMATION_CANCELLED" | "AUTOMATION_TRANSPORT_ERROR" | "AUTOMATION_RESPONSE_INVALID" | "AUTOMATION_OPERATION_CONFLICT";
+declare class XenoAutomationError extends Error {
+    readonly code: XenoAutomationErrorCode;
+    readonly detail?: Record<string, string | number | boolean | null> | undefined;
+    constructor(code: XenoAutomationErrorCode, message: string, detail?: Record<string, string | number | boolean | null> | undefined, options?: ErrorOptions);
+}
+declare function assertValidXenoAutomationRequest(request: XenoAutomationRequest): void;
+declare function assertValidXenoAutomationAdapterManifest(manifest: XenoAutomationAdapterManifest): void;
+declare function assertXenoAutomationAuthority(request: XenoAutomationRequest, manifest: XenoAutomationAdapterManifest, observedTarget: XenoAutomationTarget): void;
+declare function buildXenoAutomationCapabilityUse(request: XenoAutomationRequest, target: XenoAutomationTarget): XenoCapabilityUse;
+declare function resolveXenoAutomationEvidencePolicy(request: XenoAutomationRequest): XenoAutomationEvidencePolicy;
+interface XenoArtifactMutationOptions {
+    expectedRecordVersion?: number;
+}
+interface XenoArtifactRevisionOptions extends XenoArtifactMutationOptions {
+    actor?: XenoArtifactActor;
+    reason?: string;
+}
+interface XenoArtifactTransitionRequest extends XenoArtifactMutationOptions {
+    artifactId: string;
+    revision?: number;
+    toState: XenoArtifactState;
+    actor: XenoArtifactActor;
+    reason?: string;
+    reviewEventId?: string;
+}
+interface XenoArtifactAppendReviewRequest extends XenoArtifactMutationOptions {
+    event: XenoArtifactReviewEventInput;
+}
+interface XenoArtifactRepository {
+    create(artifact: XenoArtifactEnvelope): Promise<XenoArtifactRecord>;
+    createRevision(artifact: XenoArtifactEnvelope, options?: XenoArtifactRevisionOptions): Promise<XenoArtifactRecord>;
+    get(artifactId: string, revision?: number): Promise<XenoArtifactRecord | undefined>;
+    require(artifactId: string, revision?: number): Promise<XenoArtifactRecord>;
+    list(query?: XenoArtifactListQuery): Promise<XenoArtifactRecord[]>;
+    listRevisions(artifactId: string): Promise<XenoArtifactRecord[]>;
+    transition(request: XenoArtifactTransitionRequest): Promise<XenoArtifactRecord>;
+    appendReviewEvent(request: XenoArtifactAppendReviewRequest): Promise<XenoArtifactRecord>;
+}
+interface MaterializeXenoAutomationEvidenceOptions {
+    request: XenoAutomationRequest;
+    manifest: XenoAutomationAdapterManifest;
+    policy: XenoAutomationEvidencePolicy;
+    evidence: readonly XenoAutomationEvidenceInput[];
+    now?: () => string;
+}
+declare function materializeXenoAutomationEvidence(options: MaterializeXenoAutomationEvidenceOptions): XenoArtifactEnvelope[];
+declare function persistXenoAutomationEvidence(repository: XenoArtifactRepository | undefined, artifacts: readonly XenoArtifactEnvelope[]): Promise<XenoArtifactEnvelope[]>;
+declare function assertRequiredXenoAutomationEvidence(evidence: readonly XenoAutomationEvidenceInput[], policy: XenoAutomationEvidencePolicy, phase: "before" | "after" | "recording"): void;
+interface XenoGovernedAutomationExecutorOptions {
+    adapter: XenoAutomationAdapter;
+    leaseAuthority: XenoAutomationLeaseAuthority;
+    artifactRepository?: XenoArtifactRepository;
+    now?: () => string;
+}
+declare class XenoGovernedAutomationExecutor {
+    private readonly adapter;
+    private readonly leaseAuthority;
+    private readonly artifactRepository?;
+    private readonly now;
+    private readonly executions;
+    private readonly active;
+    constructor(options: XenoGovernedAutomationExecutorOptions);
+    execute(request: XenoAutomationRequest, signal?: AbortSignal): Promise<XenoAutomationExecutionResult>;
+    stop(operationId: string, reason?: string): Promise<boolean>;
+    private executeFresh;
+    private trimIdempotencyRecords;
+}
+declare function createXenoAutomationConformanceReport(manifest: XenoAutomationAdapterManifest, now?: () => string): XenoAutomationConformanceReport;
+declare function assertXenoAutomationAdapterConformant(manifest: XenoAutomationAdapterManifest): void;
+interface XenoLoopbackAutomationAdapterOptions {
+    baseUrl: string;
+    token: string;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    fetch?: typeof globalThis.fetch;
+}
+declare class XenoLoopbackAutomationAdapter implements XenoAutomationAdapter {
+    private readonly endpoint;
+    private readonly token;
+    private readonly timeoutMs;
+    private readonly maxResponseBytes;
+    private readonly fetchImpl;
+    constructor(options: XenoLoopbackAutomationAdapterOptions);
+    manifest(): Promise<XenoAutomationAdapterManifest>;
+    preflight(request: XenoAutomationRequest, signal: AbortSignal): Promise<XenoAutomationPreflight>;
+    execute(request: XenoAutomationRequest, preflight: XenoAutomationPreflight, grant: XenoAutomationExecutionGrant, signal: AbortSignal): Promise<XenoAutomationAdapterExecutionResult>;
+    stop(operationId: string, reason: string): Promise<void>;
+    private request;
+}
+interface XenoGovernedAutomationToolExecution {
+    operation: XenoAutomationOperation;
+    governingToolName: string;
+    operationId: string;
+    idempotencyKey: string;
+    parameters: Record<string, unknown>;
+    declaredTarget?: XenoAutomationTarget;
+    authorization: ToolAuthorizationReceipt;
+    signal?: AbortSignal;
+    reportProgress?: ToolExecutionContext["reportProgress"];
+}
+interface XenoGovernedAutomationToolRuntime {
+    execute(input: XenoGovernedAutomationToolExecution): Promise<XenoAutomationExecutionResult>;
+    stop?(operationId: string, reason?: string): Promise<boolean> | boolean;
+}
+interface CreateXenoGovernedAutomationToolsOptions {
+    runtime: XenoGovernedAutomationToolRuntime;
+    operations?: readonly XenoAutomationOperation[];
+}
+declare function createXenoGovernedAutomationTools(options: CreateXenoGovernedAutomationToolsOptions): RegisteredTool[];
+export { type CreateXenoGovernedAutomationToolsOptions, type MaterializeXenoAutomationEvidenceOptions, XENO_AUTOMATION_OPERATIONS, XENO_AUTOMATION_PROTOCOL_VERSION, type XenoAutomationAdapter, type XenoAutomationAdapterExecutionResult, type XenoAutomationAdapterManifest, type XenoAutomationConformanceCheck, type XenoAutomationConformanceReport, type XenoAutomationEffect, XenoAutomationError, type XenoAutomationErrorCode, type XenoAutomationEvidenceContent, type XenoAutomationEvidenceInput, type XenoAutomationEvidencePhase, type XenoAutomationEvidencePolicy, type XenoAutomationExecutionGrant, type XenoAutomationExecutionResult, type XenoAutomationIdentity, type XenoAutomationLeaseAuthority, type XenoAutomationOperation, type XenoAutomationOperationDescriptor, type XenoAutomationPreflight, type XenoAutomationRequest, type XenoAutomationSurface, type XenoAutomationTarget, type XenoBrowserAutomationOperation, type XenoComputerAutomationOperation, XenoGovernedAutomationExecutor, type XenoGovernedAutomationExecutorOptions, type XenoGovernedAutomationToolExecution, type XenoGovernedAutomationToolRuntime, XenoLoopbackAutomationAdapter, type XenoLoopbackAutomationAdapterOptions, assertRequiredXenoAutomationEvidence, assertValidXenoAutomationAdapterManifest, assertValidXenoAutomationRequest, assertXenoAutomationAdapterConformant, assertXenoAutomationAuthority, buildXenoAutomationCapabilityUse, createXenoAutomationConformanceReport, createXenoGovernedAutomationTools, describeXenoAutomationOperation, isXenoAutomationOperation, materializeXenoAutomationEvidence, persistXenoAutomationEvidence, resolveXenoAutomationEvidencePolicy };