@native-knowledge/knowledge-sdk 0.0.0-stage → 0.1.0-rc.1

package/dist/types/serving-contracts/agent-guidance-shapes.d.ts

@@ -0,0 +1,263 @@
+/** Optional presentation extension. No new execution authority or automatic actions. */
+import { z } from 'zod';
+export declare const agentGuidanceHeader = "x-knowledge-agent-guidance", agentGuidanceFeature = "task-guidance-v1", agentResupplyGuidanceFeature = "task-guidance-v2";
+export declare const agentGuidanceActionSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    tool: z.ZodEnum<{
+        knowledge_discover: "knowledge_discover";
+        knowledge_execute: "knowledge_execute";
+    }>;
+    arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    canExecute: z.ZodBoolean;
+    automatic: z.ZodLiteral<false>;
+    missingFields: z.ZodArray<z.ZodString>;
+    reasonCode: z.ZodString;
+}, z.core.$strict>;
+export declare const agentInputHintSchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        MISSING: "MISSING";
+        INVALID: "INVALID";
+        UNSUPPORTED: "UNSUPPORTED";
+        CONFLICT: "CONFLICT";
+    }>;
+    expected: z.ZodString;
+    prompt: z.ZodString;
+    source: z.ZodEnum<{
+        USER_INPUT: "USER_INPUT";
+        CURRENT_STATE: "CURRENT_STATE";
+        PRIOR_RESULT: "PRIOR_RESULT";
+        INDEPENDENT_REVIEW: "INDEPENDENT_REVIEW";
+    }>;
+    choices: z.ZodArray<z.ZodJSONSchema>;
+    constraints: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+export declare const agentTaskContextSchema: z.ZodObject<{
+    query: z.ZodOptional<z.ZodString>;
+    ref: z.ZodOptional<z.ZodString>;
+    jobRef: z.ZodOptional<z.ZodString>;
+    projectRef: z.ZodOptional<z.ZodString>;
+    projectKey: z.ZodOptional<z.ZodString>;
+    sourceId: z.ZodOptional<z.ZodString>;
+    requestId: z.ZodOptional<z.ZodString>;
+    recipientTenantId: z.ZodOptional<z.ZodString>;
+    sourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    spec: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    extraction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    citation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+export declare const agentTaskInputSchema: z.ZodObject<{
+    goal: z.ZodString;
+    context: z.ZodDefault<z.ZodObject<{
+        query: z.ZodOptional<z.ZodString>;
+        ref: z.ZodOptional<z.ZodString>;
+        jobRef: z.ZodOptional<z.ZodString>;
+        projectRef: z.ZodOptional<z.ZodString>;
+        projectKey: z.ZodOptional<z.ZodString>;
+        sourceId: z.ZodOptional<z.ZodString>;
+        requestId: z.ZodOptional<z.ZodString>;
+        recipientTenantId: z.ZodOptional<z.ZodString>;
+        sourceRefs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        spec: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        extraction: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        citation: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strict>>;
+    inputs: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodJSONSchema>>>;
+}, z.core.$strict>;
+export type AgentTaskInput = z.input<typeof agentTaskInputSchema>;
+export declare const agentTaskPlanSchema: z.ZodObject<{
+    template: z.ZodEnum<{
+        RESEARCH_EXISTING: "RESEARCH_EXISTING";
+        COLLECT_WEBSITE: "COLLECT_WEBSITE";
+        INSPECT_COLLECTION: "INSPECT_COLLECTION";
+        VERIFY_CITATION: "VERIFY_CITATION";
+        PROJECT_RESEARCH: "PROJECT_RESEARCH";
+        SHARE_MATERIAL: "SHARE_MATERIAL";
+        GOVERNANCE: "GOVERNANCE";
+        UNRECOGNIZED: "UNRECOGNIZED";
+    }>;
+    status: z.ZodLiteral<"SUGGESTED_NOT_EXECUTED">;
+    steps: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        dependsOn: z.ZodArray<z.ZodString>;
+        capability: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            READY: "READY";
+            NOT_AUTHORIZED: "NOT_AUTHORIZED";
+            NEEDS_INPUT: "NEEDS_INPUT";
+            NEEDS_PRIOR_RESULT: "NEEDS_PRIOR_RESULT";
+        }>;
+        action: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            tool: z.ZodEnum<{
+                knowledge_discover: "knowledge_discover";
+                knowledge_execute: "knowledge_execute";
+            }>;
+            arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            canExecute: z.ZodBoolean;
+            automatic: z.ZodLiteral<false>;
+            missingFields: z.ZodArray<z.ZodString>;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
+        inputHints: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                MISSING: "MISSING";
+                INVALID: "INVALID";
+                UNSUPPORTED: "UNSUPPORTED";
+                CONFLICT: "CONFLICT";
+            }>;
+            expected: z.ZodString;
+            prompt: z.ZodString;
+            source: z.ZodEnum<{
+                USER_INPUT: "USER_INPUT";
+                CURRENT_STATE: "CURRENT_STATE";
+                PRIOR_RESULT: "PRIOR_RESULT";
+                INDEPENDENT_REVIEW: "INDEPENDENT_REVIEW";
+            }>;
+            choices: z.ZodArray<z.ZodJSONSchema>;
+            constraints: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    guidance: z.ZodString;
+}, z.core.$strict>;
+export declare const agentRecoverySchema: z.ZodObject<{
+    reasonCode: z.ZodEnum<{
+        INPUT_REQUIRED: "INPUT_REQUIRED";
+        CURSOR_RESTART_REQUIRED: "CURSOR_RESTART_REQUIRED";
+        STATE_CHANGED: "STATE_CHANGED";
+        INSPECT_PERSISTED_RESULT: "INSPECT_PERSISTED_RESULT";
+        SEMANTIC_PLAN_REQUIRED: "SEMANTIC_PLAN_REQUIRED";
+        AUTHORITY_REQUIRED: "AUTHORITY_REQUIRED";
+        ACCESS_BLOCKED: "ACCESS_BLOCKED";
+        OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+        INSPECT_INPUT: "INSPECT_INPUT";
+    }>;
+    summary: z.ZodString;
+    inputHints: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            MISSING: "MISSING";
+            INVALID: "INVALID";
+            UNSUPPORTED: "UNSUPPORTED";
+            CONFLICT: "CONFLICT";
+        }>;
+        expected: z.ZodString;
+        prompt: z.ZodString;
+        source: z.ZodEnum<{
+            USER_INPUT: "USER_INPUT";
+            CURRENT_STATE: "CURRENT_STATE";
+            PRIOR_RESULT: "PRIOR_RESULT";
+            INDEPENDENT_REVIEW: "INDEPENDENT_REVIEW";
+        }>;
+        choices: z.ZodArray<z.ZodJSONSchema>;
+        constraints: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+    nextActions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        tool: z.ZodEnum<{
+            knowledge_discover: "knowledge_discover";
+            knowledge_execute: "knowledge_execute";
+        }>;
+        arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        canExecute: z.ZodBoolean;
+        automatic: z.ZodLiteral<false>;
+        missingFields: z.ZodArray<z.ZodString>;
+        reasonCode: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentRecovery = z.infer<typeof agentRecoverySchema>;
+export declare const agentGuidedFailureSchema: z.ZodObject<{
+    ref: z.ZodOptional<z.ZodString>;
+    completedPhase: z.ZodOptional<z.ZodEnum<{
+        REGISTERED: "REGISTERED";
+        ROUTE_COMMITTED: "ROUTE_COMMITTED";
+        CURRENTNESS_NOTIFIED: "CURRENTNESS_NOTIFIED";
+        SOURCE_REGISTERED: "SOURCE_REGISTERED";
+        BATCH_PERSISTED: "BATCH_PERSISTED";
+        VALIDATED: "VALIDATED";
+        PERSISTED: "PERSISTED";
+        CATALOG_PROJECTED: "CATALOG_PROJECTED";
+        DECLARATION_PERSISTED: "DECLARATION_PERSISTED";
+        CURRENTNESS_RECORDED: "CURRENTNESS_RECORDED";
+        SOURCE_PERSISTED: "SOURCE_PERSISTED";
+        REQUEST_PERSISTED: "REQUEST_PERSISTED";
+        PROJECT_CONTROL_COMMITTED: "PROJECT_CONTROL_COMMITTED";
+        WEB_INTENT_PERSISTED: "WEB_INTENT_PERSISTED";
+        WEB_CONTROL_COMMITTED: "WEB_CONTROL_COMMITTED";
+    }>>;
+    errorCode: z.ZodEnum<{
+        TENANT_MANAGEMENT_INVALID_INPUT: "TENANT_MANAGEMENT_INVALID_INPUT";
+        TENANT_MANAGEMENT_FORBIDDEN: "TENANT_MANAGEMENT_FORBIDDEN";
+        TENANT_MANAGEMENT_AUTHORITY_CHANGED: "TENANT_MANAGEMENT_AUTHORITY_CHANGED";
+        TENANT_MANAGEMENT_RUNTIME_OWNER_REQUIRED: "TENANT_MANAGEMENT_RUNTIME_OWNER_REQUIRED";
+        TENANT_MANAGEMENT_IDEMPOTENCY_CONFLICT: "TENANT_MANAGEMENT_IDEMPOTENCY_CONFLICT";
+        TENANT_MANAGEMENT_VERSION_CONFLICT: "TENANT_MANAGEMENT_VERSION_CONFLICT";
+        TENANT_MANAGEMENT_SOURCE_FORBIDDEN: "TENANT_MANAGEMENT_SOURCE_FORBIDDEN";
+        TENANT_MANAGEMENT_REVIEW_REQUIRED: "TENANT_MANAGEMENT_REVIEW_REQUIRED";
+        TENANT_MANAGEMENT_POLICY_BLOCKED: "TENANT_MANAGEMENT_POLICY_BLOCKED";
+        TENANT_MANAGEMENT_UNAVAILABLE: "TENANT_MANAGEMENT_UNAVAILABLE";
+        TENANT_MANAGEMENT_INCOMPLETE: "TENANT_MANAGEMENT_INCOMPLETE";
+        TENANT_MANAGEMENT_INPUT_BUDGET: "TENANT_MANAGEMENT_INPUT_BUDGET";
+        TENANT_MANAGEMENT_NOT_FOUND: "TENANT_MANAGEMENT_NOT_FOUND";
+        TENANT_WEB_SEMANTIC_COMPILER_UNAVAILABLE: "TENANT_WEB_SEMANTIC_COMPILER_UNAVAILABLE";
+        TENANT_WEB_CONTENT_FIELD_PLAN_REQUIRED: "TENANT_WEB_CONTENT_FIELD_PLAN_REQUIRED";
+        TENANT_WEB_RETAINED_SCOPE_FORBIDDEN: "TENANT_WEB_RETAINED_SCOPE_FORBIDDEN";
+        TENANT_WEB_RESULT_NOT_FOUND: "TENANT_WEB_RESULT_NOT_FOUND";
+        TENANT_WEB_CONTROL_CONFLICT: "TENANT_WEB_CONTROL_CONFLICT";
+        TENANT_WEB_CANCELLED: "TENANT_WEB_CANCELLED";
+        TENANT_WEB_PAUSED: "TENANT_WEB_PAUSED";
+        TENANT_WEB_CYCLE_PENDING: "TENANT_WEB_CYCLE_PENDING";
+        TENANT_WEB_RUNTIME_OR_DELEGATION_UNAVAILABLE: "TENANT_WEB_RUNTIME_OR_DELEGATION_UNAVAILABLE";
+    }>;
+    guidance: z.ZodObject<{
+        reasonCode: z.ZodEnum<{
+            INPUT_REQUIRED: "INPUT_REQUIRED";
+            CURSOR_RESTART_REQUIRED: "CURSOR_RESTART_REQUIRED";
+            STATE_CHANGED: "STATE_CHANGED";
+            INSPECT_PERSISTED_RESULT: "INSPECT_PERSISTED_RESULT";
+            SEMANTIC_PLAN_REQUIRED: "SEMANTIC_PLAN_REQUIRED";
+            AUTHORITY_REQUIRED: "AUTHORITY_REQUIRED";
+            ACCESS_BLOCKED: "ACCESS_BLOCKED";
+            OUTCOME_UNKNOWN: "OUTCOME_UNKNOWN";
+            INSPECT_INPUT: "INSPECT_INPUT";
+        }>;
+        summary: z.ZodString;
+        inputHints: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                MISSING: "MISSING";
+                INVALID: "INVALID";
+                UNSUPPORTED: "UNSUPPORTED";
+                CONFLICT: "CONFLICT";
+            }>;
+            expected: z.ZodString;
+            prompt: z.ZodString;
+            source: z.ZodEnum<{
+                USER_INPUT: "USER_INPUT";
+                CURRENT_STATE: "CURRENT_STATE";
+                PRIOR_RESULT: "PRIOR_RESULT";
+                INDEPENDENT_REVIEW: "INDEPENDENT_REVIEW";
+            }>;
+            choices: z.ZodArray<z.ZodJSONSchema>;
+            constraints: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+        nextActions: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            title: z.ZodString;
+            tool: z.ZodEnum<{
+                knowledge_discover: "knowledge_discover";
+                knowledge_execute: "knowledge_execute";
+            }>;
+            arguments: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            canExecute: z.ZodBoolean;
+            automatic: z.ZodLiteral<false>;
+            missingFields: z.ZodArray<z.ZodString>;
+            reasonCode: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;

package/dist/types/serving-contracts/agent-input-hints.d.ts

@@ -0,0 +1,24 @@
+/** Derive bounded hints from the actual capability schema, never from raw validator messages. */
+import { type AgentCapabilityName } from './agent-entry.js';
+export declare function agentInputHints(name: AgentCapabilityName, raw: unknown): {
+    path: string;
+    kind: "MISSING" | "INVALID" | "UNSUPPORTED" | "CONFLICT";
+    expected: string;
+    prompt: string;
+    source: "USER_INPUT" | "CURRENT_STATE" | "PRIOR_RESULT" | "INDEPENDENT_REVIEW";
+    choices: import("zod").JSONType[];
+    constraints: Record<string, import("zod").JSONType>;
+}[];
+export declare function agentResumeArguments(name: AgentCapabilityName, raw: unknown): Record<string, unknown>;
+/** Explain invalid supplied fields and any payload fields intentionally omitted from suggestions. */
+export declare function agentCompletionHints(name: AgentCapabilityName, raw: unknown, resupplyFields?: readonly string[]): {
+    path: string;
+    kind: "MISSING" | "INVALID" | "UNSUPPORTED" | "CONFLICT";
+    expected: string;
+    prompt: string;
+    source: "USER_INPUT" | "CURRENT_STATE" | "PRIOR_RESULT" | "INDEPENDENT_REVIEW";
+    choices: import("zod").JSONType[];
+    constraints: Record<string, import("zod").JSONType>;
+}[];
+/** Carry only declared field names, never omitted values, across inspection hops. */
+export declare function agentResupplyFields(name: AgentCapabilityName, raw: unknown): string[];

package/dist/types/serving-contracts/body-search.d.ts

@@ -0,0 +1,231 @@
+/** Explicit raw-material body search; existing descriptive search contracts stay frozen. */
+import { z } from 'zod';
+export declare const agentBodySearchHeader = "x-knowledge-agent-capabilities";
+export declare const agentBodySearchFeature = "body-search-v1";
+export declare const bodyCitationSchema: z.ZodObject<{
+    ref: z.ZodString;
+    contentHash: z.ZodString;
+    jsonPointer: z.ZodNullable<z.ZodString>;
+    startUtf16: z.ZodNumber;
+    endUtf16: z.ZodNumber;
+    quote: z.ZodString;
+}, z.core.$strict>;
+export declare const bodySearchToolSchemas: {
+    readonly knowledge_resource_search_body: z.ZodObject<{
+        query: z.ZodString;
+        after: z.ZodOptional<z.ZodString>;
+        limit: z.ZodDefault<z.ZodNumber>;
+        resourceType: z.ZodOptional<z.ZodString>;
+        projectRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    readonly knowledge_resource_read_passage: z.ZodObject<{
+        citation: z.ZodObject<{
+            ref: z.ZodString;
+            contentHash: z.ZodString;
+            jsonPointer: z.ZodNullable<z.ZodString>;
+            startUtf16: z.ZodNumber;
+            endUtf16: z.ZodNumber;
+            quote: z.ZodString;
+        }, z.core.$strict>;
+        projectRef: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+};
+export declare const bodySearchDataSchemas: {
+    readonly knowledge_resource_search_body: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            item: z.ZodObject<{
+                ref: z.ZodString;
+                ownerTenantId: z.ZodString;
+                resourceType: z.ZodString;
+                origin: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"TENANT_AUTHOR">;
+                    actor: z.ZodObject<{
+                        tenantId: z.ZodString;
+                        userId: z.ZodString;
+                        agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strict>;
+                    submittedAt: z.ZodISODateTime;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"TENANT_SOURCE">;
+                    sourceId: z.ZodString;
+                    sourceRef: z.ZodString;
+                    sourceRevisionRef: z.ZodString;
+                    collector: z.ZodObject<{
+                        collectorId: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strict>;
+                    runtimeNodeId: z.ZodString;
+                    observedAt: z.ZodISODateTime;
+                }, z.core.$strict>], "type">, z.ZodObject<{
+                    type: z.ZodLiteral<"LEGACY_PROJECT">;
+                    projectKey: z.ZodString;
+                    projectRef: z.ZodString;
+                }, z.core.$strict>]>;
+                identityHash: z.ZodString;
+                identityKind: z.ZodEnum<{
+                    CAS_BYTES: "CAS_BYTES";
+                    REFERENCE_RECORD_DIGEST: "REFERENCE_RECORD_DIGEST";
+                }>;
+                kind: z.ZodString;
+                classification: z.ZodEnum<{
+                    PUBLIC: "PUBLIC";
+                    PUBLIC_METADATA: "PUBLIC_METADATA";
+                    TENANT: "TENANT";
+                    INTERNAL: "INTERNAL";
+                    FDE_INTERNAL: "FDE_INTERNAL";
+                    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+                    UNKNOWN: "UNKNOWN";
+                }>;
+                mediaType: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodString;
+                decision: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<1>;
+                    action: z.ZodEnum<{
+                        ALLOW: "ALLOW";
+                        DENY: "DENY";
+                    }>;
+                    reasonCodes: z.ZodArray<z.ZodEnum<{
+                        UNAVAILABLE: "UNAVAILABLE";
+                        NOT_FOUND: "NOT_FOUND";
+                        CONTENT_ACCESS_DENIED: "CONTENT_ACCESS_DENIED";
+                        INTEGRITY_MISMATCH: "INTEGRITY_MISMATCH";
+                        UNSUPPORTED_RESOURCE: "UNSUPPORTED_RESOURCE";
+                    }>>;
+                    assessedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            citation: z.ZodObject<{
+                ref: z.ZodString;
+                contentHash: z.ZodString;
+                jsonPointer: z.ZodNullable<z.ZodString>;
+                startUtf16: z.ZodNumber;
+                endUtf16: z.ZodNumber;
+                quote: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        nextAfter: z.ZodNullable<z.ZodString>;
+        coverage: z.ZodLiteral<"INDEXED_NATIVE_TEXT_PASSAGES_ONLY">;
+        completeness: z.ZodLiteral<"NOT_ASSESSED">;
+        semantics: z.ZodLiteral<"RAW_MATERIAL_NOT_GOVERNANCE_APPROVAL">;
+    }, z.core.$strict>;
+    readonly knowledge_resource_read_passage: z.ZodObject<{
+        citation: z.ZodObject<{
+            ref: z.ZodString;
+            contentHash: z.ZodString;
+            jsonPointer: z.ZodNullable<z.ZodString>;
+            startUtf16: z.ZodNumber;
+            endUtf16: z.ZodNumber;
+            quote: z.ZodString;
+        }, z.core.$strict>;
+        verified: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+};
+export type BodySearchToolName = keyof typeof bodySearchToolSchemas;
+export type BodyCitation = z.infer<typeof bodyCitationSchema>;
+export declare function bodySearchEnvelopeSchema(name: BodySearchToolName): z.ZodObject<{
+    schemaVersion: z.ZodLiteral<2>;
+    context: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"TENANT">;
+        tenantId: z.ZodString;
+        tenantRef: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"PROJECT">;
+        tenantId: z.ZodString;
+        projectKey: z.ZodString;
+        projectRef: z.ZodString;
+    }, z.core.$strict>], "type">;
+    policy: z.ZodEnum<{
+        LEGACY_PROJECT: "LEGACY_PROJECT";
+        TENANT_NATIVE: "TENANT_NATIVE";
+        TENANT_PROJECT_SCOPE: "TENANT_PROJECT_SCOPE";
+    }>;
+    data: z.ZodObject<{
+        items: z.ZodArray<z.ZodObject<{
+            item: z.ZodObject<{
+                ref: z.ZodString;
+                ownerTenantId: z.ZodString;
+                resourceType: z.ZodString;
+                origin: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    type: z.ZodLiteral<"TENANT_AUTHOR">;
+                    actor: z.ZodObject<{
+                        tenantId: z.ZodString;
+                        userId: z.ZodString;
+                        agentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+                    }, z.core.$strict>;
+                    submittedAt: z.ZodISODateTime;
+                }, z.core.$strict>, z.ZodObject<{
+                    type: z.ZodLiteral<"TENANT_SOURCE">;
+                    sourceId: z.ZodString;
+                    sourceRef: z.ZodString;
+                    sourceRevisionRef: z.ZodString;
+                    collector: z.ZodObject<{
+                        collectorId: z.ZodString;
+                        version: z.ZodString;
+                    }, z.core.$strict>;
+                    runtimeNodeId: z.ZodString;
+                    observedAt: z.ZodISODateTime;
+                }, z.core.$strict>], "type">, z.ZodObject<{
+                    type: z.ZodLiteral<"LEGACY_PROJECT">;
+                    projectKey: z.ZodString;
+                    projectRef: z.ZodString;
+                }, z.core.$strict>]>;
+                identityHash: z.ZodString;
+                identityKind: z.ZodEnum<{
+                    CAS_BYTES: "CAS_BYTES";
+                    REFERENCE_RECORD_DIGEST: "REFERENCE_RECORD_DIGEST";
+                }>;
+                kind: z.ZodString;
+                classification: z.ZodEnum<{
+                    PUBLIC: "PUBLIC";
+                    PUBLIC_METADATA: "PUBLIC_METADATA";
+                    TENANT: "TENANT";
+                    INTERNAL: "INTERNAL";
+                    FDE_INTERNAL: "FDE_INTERNAL";
+                    ACCESS_CONTROLLED: "ACCESS_CONTROLLED";
+                    UNKNOWN: "UNKNOWN";
+                }>;
+                mediaType: z.ZodString;
+                title: z.ZodString;
+                summary: z.ZodString;
+                decision: z.ZodObject<{
+                    schemaVersion: z.ZodLiteral<1>;
+                    action: z.ZodEnum<{
+                        ALLOW: "ALLOW";
+                        DENY: "DENY";
+                    }>;
+                    reasonCodes: z.ZodArray<z.ZodEnum<{
+                        UNAVAILABLE: "UNAVAILABLE";
+                        NOT_FOUND: "NOT_FOUND";
+                        CONTENT_ACCESS_DENIED: "CONTENT_ACCESS_DENIED";
+                        INTEGRITY_MISMATCH: "INTEGRITY_MISMATCH";
+                        UNSUPPORTED_RESOURCE: "UNSUPPORTED_RESOURCE";
+                    }>>;
+                    assessedAt: z.ZodISODateTime;
+                }, z.core.$strict>;
+            }, z.core.$strict>;
+            citation: z.ZodObject<{
+                ref: z.ZodString;
+                contentHash: z.ZodString;
+                jsonPointer: z.ZodNullable<z.ZodString>;
+                startUtf16: z.ZodNumber;
+                endUtf16: z.ZodNumber;
+                quote: z.ZodString;
+            }, z.core.$strict>;
+        }, z.core.$strict>>;
+        nextAfter: z.ZodNullable<z.ZodString>;
+        coverage: z.ZodLiteral<"INDEXED_NATIVE_TEXT_PASSAGES_ONLY">;
+        completeness: z.ZodLiteral<"NOT_ASSESSED">;
+        semantics: z.ZodLiteral<"RAW_MATERIAL_NOT_GOVERNANCE_APPROVAL">;
+    }, z.core.$strict> | z.ZodObject<{
+        citation: z.ZodObject<{
+            ref: z.ZodString;
+            contentHash: z.ZodString;
+            jsonPointer: z.ZodNullable<z.ZodString>;
+            startUtf16: z.ZodNumber;
+            endUtf16: z.ZodNumber;
+            quote: z.ZodString;
+        }, z.core.$strict>;
+        verified: z.ZodLiteral<true>;
+    }, z.core.$strict>;
+}, z.core.$strict>;