@phyzess/pappra 0.0.0-stage → 0.1.0-beta.2

package/dist/package-info.d.ts

@@ -0,0 +1,6 @@
+export interface PackageInfo {
+    readonly name: string;
+    readonly version: string;
+    readonly description: string;
+}
+export declare function getPackageInfo(): PackageInfo;

package/dist/package-info.js

@@ -0,0 +1,19 @@
+import { readFileSync } from 'node:fs';
+export function getPackageInfo() {
+    const value = JSON.parse(readFileSync(new URL(import.meta.resolve('@phyzess/pappra/package.json')), 'utf8'));
+    if (typeof value !== 'object' ||
+        value === null ||
+        !('name' in value) ||
+        typeof value.name !== 'string' ||
+        !('version' in value) ||
+        typeof value.version !== 'string' ||
+        !('description' in value) ||
+        typeof value.description !== 'string') {
+        throw new Error('The installed Pappra package metadata is invalid.');
+    }
+    return {
+        name: value.name,
+        version: value.version,
+        description: value.description,
+    };
+}

package/dist/schemas/code.d.ts

@@ -0,0 +1,377 @@
+import { z } from 'zod';
+export declare const codeWorkingTreeSchema: z.ZodObject<{
+    digest: z.ZodString;
+    completeness: z.ZodEnum<{
+        complete: "complete";
+        partial: "partial";
+        unknown: "unknown";
+    }>;
+    fileCount: z.ZodNumber;
+    byteCount: z.ZodNumber;
+    reasons: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const codeEngineSchema: z.ZodObject<{
+    id: z.ZodLiteral<"codegraph">;
+    version: z.ZodString;
+    configDigest: z.ZodString;
+    configStatus: z.ZodOptional<z.ZodEnum<{
+        default: "default";
+        observed: "observed";
+        unknown: "unknown";
+    }>>;
+}, z.core.$strict>;
+export declare const codeIdentitySchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-identity/1">;
+    repositoryId: z.ZodString;
+    checkoutId: z.ZodString;
+    root: z.ZodString;
+    gitDir: z.ZodNullable<z.ZodString>;
+    gitCommonDir: z.ZodNullable<z.ZodString>;
+    head: z.ZodNullable<z.ZodString>;
+    branch: z.ZodNullable<z.ZodString>;
+    workingTree: z.ZodObject<{
+        digest: z.ZodString;
+        completeness: z.ZodEnum<{
+            complete: "complete";
+            partial: "partial";
+            unknown: "unknown";
+        }>;
+        fileCount: z.ZodNumber;
+        byteCount: z.ZodNumber;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    engine: z.ZodObject<{
+        id: z.ZodLiteral<"codegraph">;
+        version: z.ZodString;
+        configDigest: z.ZodString;
+        configStatus: z.ZodOptional<z.ZodEnum<{
+            default: "default";
+            observed: "observed";
+            unknown: "unknown";
+        }>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export declare const codeIndexCoverageSchema: z.ZodObject<{
+    scope: z.ZodLiteral<"selected-repository">;
+    languages: z.ZodArray<z.ZodString>;
+    semantic: z.ZodBoolean;
+    callGraph: z.ZodBoolean;
+    note: z.ZodString;
+}, z.core.$strict>;
+export declare const codeIndexHealthSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-index-health/1">;
+    state: z.ZodEnum<{
+        building: "building";
+        failed: "failed";
+        missing: "missing";
+        partial: "partial";
+        ready: "ready";
+        stale: "stale";
+        unsupported: "unsupported";
+    }>;
+    reasons: z.ZodArray<z.ZodString>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            file: "file";
+            git: "git";
+            "native-event": "native-event";
+            "runtime-probe": "runtime-probe";
+        }>;
+        ref: z.ZodString;
+        digest: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        scope: z.ZodEnum<{
+            declared: "declared";
+            "live-owned": "live-owned";
+            persisted: "persisted";
+        }>;
+    }, z.core.$strict>>;
+    coverage: z.ZodObject<{
+        scope: z.ZodLiteral<"selected-repository">;
+        languages: z.ZodArray<z.ZodString>;
+        semantic: z.ZodBoolean;
+        callGraph: z.ZodBoolean;
+        note: z.ZodString;
+    }, z.core.$strict>;
+    engineVersion: z.ZodString;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export declare const codeQueryKindSchema: z.ZodEnum<{
+    explore: "explore";
+    impact: "impact";
+    references: "references";
+    symbol: "symbol";
+    text: "text";
+}>;
+export declare const codeQueryLimitsSchema: z.ZodObject<{
+    maxResults: z.ZodNumber;
+    maxBytes: z.ZodNumber;
+    maxFiles: z.ZodNumber;
+}, z.core.$strict>;
+export declare const codeQueryRequestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-query/1">;
+    kind: z.ZodEnum<{
+        explore: "explore";
+        impact: "impact";
+        references: "references";
+        symbol: "symbol";
+        text: "text";
+    }>;
+    query: z.ZodString;
+    identity: z.ZodObject<{
+        schema: z.ZodLiteral<"pappra/code-identity/1">;
+        repositoryId: z.ZodString;
+        checkoutId: z.ZodString;
+        root: z.ZodString;
+        gitDir: z.ZodNullable<z.ZodString>;
+        gitCommonDir: z.ZodNullable<z.ZodString>;
+        head: z.ZodNullable<z.ZodString>;
+        branch: z.ZodNullable<z.ZodString>;
+        workingTree: z.ZodObject<{
+            digest: z.ZodString;
+            completeness: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+                unknown: "unknown";
+            }>;
+            fileCount: z.ZodNumber;
+            byteCount: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        engine: z.ZodObject<{
+            id: z.ZodLiteral<"codegraph">;
+            version: z.ZodString;
+            configDigest: z.ZodString;
+            configStatus: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                observed: "observed";
+                unknown: "unknown";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    limits: z.ZodObject<{
+        maxResults: z.ZodNumber;
+        maxBytes: z.ZodNumber;
+        maxFiles: z.ZodNumber;
+    }, z.core.$strict>;
+    excludedRoots: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare const codeQueryItemSchema: z.ZodObject<{
+    path: z.ZodString;
+    line: z.ZodNullable<z.ZodNumber>;
+    column: z.ZodNullable<z.ZodNumber>;
+    kind: z.ZodString;
+    name: z.ZodNullable<z.ZodString>;
+    snippet: z.ZodString;
+    source: z.ZodEnum<{
+        codegraph: "codegraph";
+        structure: "structure";
+        text: "text";
+    }>;
+}, z.core.$strict>;
+export declare const codeQueryResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-query-result/1">;
+    provider: z.ZodEnum<{
+        codegraph: "codegraph";
+        structure: "structure";
+        text: "text";
+    }>;
+    kind: z.ZodEnum<{
+        explore: "explore";
+        impact: "impact";
+        references: "references";
+        symbol: "symbol";
+        text: "text";
+    }>;
+    query: z.ZodString;
+    identityDigest: z.ZodString;
+    observedIdentity: z.ZodObject<{
+        schema: z.ZodLiteral<"pappra/code-identity/1">;
+        repositoryId: z.ZodString;
+        checkoutId: z.ZodString;
+        root: z.ZodString;
+        gitDir: z.ZodNullable<z.ZodString>;
+        gitCommonDir: z.ZodNullable<z.ZodString>;
+        head: z.ZodNullable<z.ZodString>;
+        branch: z.ZodNullable<z.ZodString>;
+        workingTree: z.ZodObject<{
+            digest: z.ZodString;
+            completeness: z.ZodEnum<{
+                complete: "complete";
+                partial: "partial";
+                unknown: "unknown";
+            }>;
+            fileCount: z.ZodNumber;
+            byteCount: z.ZodNumber;
+            reasons: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        engine: z.ZodObject<{
+            id: z.ZodLiteral<"codegraph">;
+            version: z.ZodString;
+            configDigest: z.ZodString;
+            configStatus: z.ZodOptional<z.ZodEnum<{
+                default: "default";
+                observed: "observed";
+                unknown: "unknown";
+            }>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    coverage: z.ZodEnum<{
+        complete: "complete";
+        fallback: "fallback";
+        partial: "partial";
+        unsupported: "unsupported";
+    }>;
+    items: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        line: z.ZodNullable<z.ZodNumber>;
+        column: z.ZodNullable<z.ZodNumber>;
+        kind: z.ZodString;
+        name: z.ZodNullable<z.ZodString>;
+        snippet: z.ZodString;
+        source: z.ZodEnum<{
+            codegraph: "codegraph";
+            structure: "structure";
+            text: "text";
+        }>;
+    }, z.core.$strict>>;
+    bytes: z.ZodNumber;
+    truncated: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodString>;
+    evidence: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            file: "file";
+            git: "git";
+            "native-event": "native-event";
+            "runtime-probe": "runtime-probe";
+        }>;
+        ref: z.ZodString;
+        digest: z.ZodNullable<z.ZodString>;
+        observedAt: z.ZodISODateTime;
+        scope: z.ZodEnum<{
+            declared: "declared";
+            "live-owned": "live-owned";
+            persisted: "persisted";
+        }>;
+    }, z.core.$strict>>;
+    unsupportedReason: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export declare const codePrepareActionSchema: z.ZodEnum<{
+    init: "init";
+    none: "none";
+    rebuild: "rebuild";
+    sync: "sync";
+}>;
+export declare const codePreparePlanSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-prepare-plan/1">;
+    repositoryId: z.ZodString;
+    identityDigest: z.ZodString;
+    action: z.ZodEnum<{
+        init: "init";
+        none: "none";
+        rebuild: "rebuild";
+        sync: "sync";
+    }>;
+    indexPath: z.ZodString;
+    command: z.ZodArray<z.ZodString>;
+    mutates: z.ZodBoolean;
+    reasons: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const codePrepareResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-prepare-result/1">;
+    ok: z.ZodBoolean;
+    status: z.ZodEnum<{
+        conflict: "conflict";
+        failed: "failed";
+        partial: "partial";
+        planned: "planned";
+        ready: "ready";
+        unsupported: "unsupported";
+    }>;
+    plan: z.ZodObject<{
+        schema: z.ZodLiteral<"pappra/code-prepare-plan/1">;
+        repositoryId: z.ZodString;
+        identityDigest: z.ZodString;
+        action: z.ZodEnum<{
+            init: "init";
+            none: "none";
+            rebuild: "rebuild";
+            sync: "sync";
+        }>;
+        indexPath: z.ZodString;
+        command: z.ZodArray<z.ZodString>;
+        mutates: z.ZodBoolean;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    health: z.ZodObject<{
+        schema: z.ZodLiteral<"pappra/code-index-health/1">;
+        state: z.ZodEnum<{
+            building: "building";
+            failed: "failed";
+            missing: "missing";
+            partial: "partial";
+            ready: "ready";
+            stale: "stale";
+            unsupported: "unsupported";
+        }>;
+        reasons: z.ZodArray<z.ZodString>;
+        evidence: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                file: "file";
+                git: "git";
+                "native-event": "native-event";
+                "runtime-probe": "runtime-probe";
+            }>;
+            ref: z.ZodString;
+            digest: z.ZodNullable<z.ZodString>;
+            observedAt: z.ZodISODateTime;
+            scope: z.ZodEnum<{
+                declared: "declared";
+                "live-owned": "live-owned";
+                persisted: "persisted";
+            }>;
+        }, z.core.$strict>>;
+        coverage: z.ZodObject<{
+            scope: z.ZodLiteral<"selected-repository">;
+            languages: z.ZodArray<z.ZodString>;
+            semantic: z.ZodBoolean;
+            callGraph: z.ZodBoolean;
+            note: z.ZodString;
+        }, z.core.$strict>;
+        engineVersion: z.ZodString;
+        observedAt: z.ZodISODateTime;
+    }, z.core.$strict>;
+    registrationPath: z.ZodNullable<z.ZodString>;
+    diagnostics: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export declare const codeIndexRegistrationSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/code-index-registration/1">;
+    repositoryId: z.ZodString;
+    identityDigest: z.ZodString;
+    checkoutId: z.ZodString;
+    root: z.ZodString;
+    engineVersion: z.ZodString;
+    configDigest: z.ZodString;
+    preparedAt: z.ZodISODateTime;
+    coverage: z.ZodObject<{
+        scope: z.ZodLiteral<"selected-repository">;
+        languages: z.ZodArray<z.ZodString>;
+        semantic: z.ZodBoolean;
+        callGraph: z.ZodBoolean;
+        note: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type CodeWorkingTree = z.infer<typeof codeWorkingTreeSchema>;
+export type CodeEngine = z.infer<typeof codeEngineSchema>;
+export type CodeIdentity = z.infer<typeof codeIdentitySchema>;
+export type CodeIndexCoverage = z.infer<typeof codeIndexCoverageSchema>;
+export type CodeIndexHealth = z.infer<typeof codeIndexHealthSchema>;
+export type CodeQueryKind = z.infer<typeof codeQueryKindSchema>;
+export type CodeQueryLimits = z.infer<typeof codeQueryLimitsSchema>;
+export type CodeQueryRequest = z.infer<typeof codeQueryRequestSchema>;
+export type CodeQueryItem = z.infer<typeof codeQueryItemSchema>;
+export type CodeQueryResult = z.infer<typeof codeQueryResultSchema>;
+export type CodePrepareAction = z.infer<typeof codePrepareActionSchema>;
+export type CodePreparePlan = z.infer<typeof codePreparePlanSchema>;
+export type CodePrepareResult = z.infer<typeof codePrepareResultSchema>;
+export type CodeIndexRegistration = z.infer<typeof codeIndexRegistrationSchema>;

package/dist/schemas/code.js

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { evidenceRefSchema } from './evidence.js';
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const reasonSchema = z.string().min(1).max(512);
+const relativePathSchema = z.string().min(1).max(2048);
+export const codeWorkingTreeSchema = z.strictObject({
+    digest: digestSchema,
+    completeness: z.enum(['complete', 'partial', 'unknown']),
+    fileCount: z.number().int().nonnegative(),
+    byteCount: z.number().int().nonnegative(),
+    reasons: z.array(reasonSchema).max(16),
+});
+export const codeEngineSchema = z.strictObject({
+    id: z.literal('codegraph'),
+    version: z.string().min(1).max(64),
+    configDigest: digestSchema,
+    configStatus: z.enum(['default', 'observed', 'unknown']).optional(),
+});
+export const codeIdentitySchema = z.strictObject({
+    schema: z.literal('pappra/code-identity/1'),
+    repositoryId: z.string().min(1).max(64),
+    checkoutId: z.string().min(1).max(128),
+    root: z.string().min(1).max(4096),
+    gitDir: z.string().min(1).max(4096).nullable(),
+    gitCommonDir: z.string().min(1).max(4096).nullable(),
+    head: z.string().max(256).nullable(),
+    branch: z.string().max(512).nullable(),
+    workingTree: codeWorkingTreeSchema,
+    engine: codeEngineSchema,
+});
+export const codeIndexCoverageSchema = z.strictObject({
+    scope: z.literal('selected-repository'),
+    languages: z.array(z.string().min(1).max(64)).max(64),
+    semantic: z.boolean(),
+    callGraph: z.boolean(),
+    note: z.string().min(1).max(1024),
+});
+export const codeIndexHealthSchema = z.strictObject({
+    schema: z.literal('pappra/code-index-health/1'),
+    state: z.enum([
+        'missing',
+        'building',
+        'ready',
+        'stale',
+        'partial',
+        'failed',
+        'unsupported',
+    ]),
+    reasons: z.array(reasonSchema).max(32),
+    evidence: z.array(evidenceRefSchema).max(32),
+    coverage: codeIndexCoverageSchema,
+    engineVersion: z.string().min(1).max(64),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+export const codeQueryKindSchema = z.enum([
+    'explore',
+    'symbol',
+    'references',
+    'impact',
+    'text',
+]);
+export const codeQueryLimitsSchema = z.strictObject({
+    maxResults: z.number().int().min(1).max(100),
+    maxBytes: z
+        .number()
+        .int()
+        .min(1)
+        .max(16 * 1024 * 1024),
+    maxFiles: z.number().int().min(1).max(5000),
+});
+export const codeQueryRequestSchema = z.strictObject({
+    schema: z.literal('pappra/code-query/1'),
+    kind: codeQueryKindSchema,
+    query: z.string().min(1).max(1024),
+    identity: codeIdentitySchema,
+    limits: codeQueryLimitsSchema,
+    excludedRoots: z.array(z.string().min(1).max(4096)).max(64).optional(),
+});
+export const codeQueryItemSchema = z.strictObject({
+    path: relativePathSchema,
+    line: z.number().int().positive().nullable(),
+    column: z.number().int().nonnegative().nullable(),
+    kind: z.string().min(1).max(64),
+    name: z.string().max(512).nullable(),
+    snippet: z.string().max(4096),
+    source: z.enum(['codegraph', 'text', 'structure']),
+});
+export const codeQueryResultSchema = z.strictObject({
+    schema: z.literal('pappra/code-query-result/1'),
+    provider: z.enum(['codegraph', 'text', 'structure']),
+    kind: codeQueryKindSchema,
+    query: z.string().min(1).max(1024),
+    identityDigest: digestSchema,
+    observedIdentity: codeIdentitySchema,
+    coverage: z.enum(['complete', 'partial', 'fallback', 'unsupported']),
+    items: z.array(codeQueryItemSchema).max(100),
+    bytes: z.number().int().nonnegative(),
+    truncated: z.boolean(),
+    reasons: z.array(reasonSchema).max(16),
+    evidence: z.array(evidenceRefSchema).max(32),
+    unsupportedReason: z.string().max(1024).nullable(),
+});
+export const codePrepareActionSchema = z.enum([
+    'none',
+    'init',
+    'sync',
+    'rebuild',
+]);
+export const codePreparePlanSchema = z.strictObject({
+    schema: z.literal('pappra/code-prepare-plan/1'),
+    repositoryId: z.string().min(1).max(64),
+    identityDigest: digestSchema,
+    action: codePrepareActionSchema,
+    indexPath: z.string().min(1).max(4096),
+    command: z.array(z.string().max(4096)).max(16),
+    mutates: z.boolean(),
+    reasons: z.array(reasonSchema).max(16),
+});
+export const codePrepareResultSchema = z.strictObject({
+    schema: z.literal('pappra/code-prepare-result/1'),
+    ok: z.boolean(),
+    status: z.enum([
+        'planned',
+        'ready',
+        'partial',
+        'failed',
+        'conflict',
+        'unsupported',
+    ]),
+    plan: codePreparePlanSchema,
+    health: codeIndexHealthSchema,
+    registrationPath: z.string().max(4096).nullable(),
+    diagnostics: z.array(z.unknown()).max(32),
+});
+export const codeIndexRegistrationSchema = z.strictObject({
+    schema: z.literal('pappra/code-index-registration/1'),
+    repositoryId: z.string().min(1).max(64),
+    identityDigest: digestSchema,
+    checkoutId: z.string().min(1).max(128),
+    root: z.string().min(1).max(4096),
+    engineVersion: z.string().min(1).max(64),
+    configDigest: digestSchema,
+    preparedAt: z.iso.datetime({ offset: true }),
+    coverage: codeIndexCoverageSchema,
+});

package/dist/schemas/collaboration.d.ts

@@ -0,0 +1,115 @@
+import { z } from 'zod';
+export declare const collaborationGoalSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-goal/1">;
+    task_id: z.ZodString;
+    subtask_id: z.ZodString;
+    attempt: z.ZodNumber;
+    phase: z.ZodEnum<{
+        discovery: "discovery";
+        fix: "fix";
+        handoff: "handoff";
+        implementation: "implementation";
+        review: "review";
+    }>;
+    objective: z.ZodString;
+    acceptance: z.ZodArray<z.ZodString>;
+    prompt: z.ZodString;
+    coordinator: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodString;
+        owner_epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    assignee: z.ZodObject<{
+        agent_id: z.ZodString;
+        session_id: z.ZodString;
+        harness: z.ZodString;
+        cwd: z.ZodString;
+        surface: z.ZodString;
+        configuration_id: z.ZodString;
+    }, z.core.$strict>;
+    resources: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        access: z.ZodEnum<{
+            read: "read";
+            write: "write";
+        }>;
+    }, z.core.$strict>>;
+    required: z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            bundle_digest: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    preferred: z.ZodDefault<z.ZodObject<{
+        skills: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            bundle_digest: z.ZodString;
+        }, z.core.$strict>>;
+        tools: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CollaborationGoal = z.infer<typeof collaborationGoalSchema>;
+export declare const collaborationPreparedSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-prepared/1">;
+    task_id: z.ZodString;
+    subtask_id: z.ZodString;
+    attempt: z.ZodNumber;
+    phase: z.ZodString;
+    task_root: z.ZodString;
+    domain_root: z.ZodString;
+    prepared_dir: z.ZodString;
+    assignment_path: z.ZodString;
+    prompt_path: z.ZodString;
+    goal_path: z.ZodString;
+    assignment_digest: z.ZodString;
+    prompt_digest: z.ZodString;
+    resource_epochs: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    claim_ids: z.ZodArray<z.ZodString>;
+    state_revision: z.ZodNumber;
+    created_at: z.ZodString;
+}, z.core.$strict>;
+export type CollaborationPrepared = z.infer<typeof collaborationPreparedSchema>;
+export declare const collaborationCommandSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-command/1">;
+    action: z.ZodLiteral<"query">;
+    request_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-command/1">;
+    action: z.ZodLiteral<"cancel">;
+    request_id: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-command/1">;
+    action: z.ZodLiteral<"finish">;
+    request_id: z.ZodString;
+    status: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        failed: "failed";
+        needs_input: "needs_input";
+        unknown: "unknown";
+    }>;
+    outputs: z.ZodDefault<z.ZodArray<z.ZodUnknown>>;
+    native_ref: z.ZodDefault<z.ZodNullable<z.ZodUnknown>>;
+    evidence_ref: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>], "action">;
+export type CollaborationCommand = z.infer<typeof collaborationCommandSchema>;
+export declare const collaborationEventSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/collaboration-event/1">;
+    sequence: z.ZodNumber;
+    request_id: z.ZodNullable<z.ZodString>;
+    kind: z.ZodEnum<{
+        cancel: "cancel";
+        finished: "finished";
+        query: "query";
+        refused: "refused";
+        report: "report";
+        started: "started";
+    }>;
+    at: z.ZodString;
+    status: z.ZodString;
+    detail: z.ZodNullable<z.ZodString>;
+    data: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strict>;
+export type CollaborationEvent = z.infer<typeof collaborationEventSchema>;