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

package/dist/schemas/evidence.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export const evidenceScopeSchema = z.enum([
+    'persisted',
+    'live-owned',
+    'declared',
+]);
+export const evidenceRefSchema = z.strictObject({
+    kind: z.enum(['file', 'native-event', 'git', 'runtime-probe']),
+    ref: z.string().min(1),
+    digest: z
+        .string()
+        .regex(/^sha256:[0-9a-f]{64}$/)
+        .nullable(),
+    observedAt: z.iso.datetime({ offset: true }),
+    scope: evidenceScopeSchema,
+});

package/dist/schemas/host.d.ts

@@ -0,0 +1,436 @@
+import { z } from 'zod';
+export declare const HOST_INTEGRATION_SCHEMA = "pappra/host-integration/1";
+export declare const HOST_CAPABILITIES_SCHEMA = "pappra/host-capabilities/1";
+export declare const HOST_BUNDLE_SCHEMA = "pappra/host-bundle/1";
+export declare const HOST_HOOK_INPUT_SCHEMA = "pappra/host-hook-input/1";
+export declare const HOST_HOOK_RESULT_SCHEMA = "pappra/host-hook-result/1";
+export declare const hostNameSchema: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    pi: "pi";
+}>;
+export type HostName = z.infer<typeof hostNameSchema>;
+export declare const hostLifecycleEventSchema: z.ZodEnum<{
+    "checkpoint-request": "checkpoint-request";
+    compact: "compact";
+    resume: "resume";
+    startup: "startup";
+}>;
+export type HostLifecycleEvent = z.infer<typeof hostLifecycleEventSchema>;
+export declare const hostCapabilityStateSchema: z.ZodEnum<{
+    callable: "callable";
+    configured: "configured";
+    discovered: "discovered";
+    installed: "installed";
+    unknown: "unknown";
+    unsupported: "unsupported";
+    verified: "verified";
+}>;
+export type HostCapabilityState = z.infer<typeof hostCapabilityStateSchema>;
+export declare const hostCapabilitySchema: z.ZodObject<{
+    event: z.ZodEnum<{
+        "checkpoint-request": "checkpoint-request";
+        compact: "compact";
+        resume: "resume";
+        startup: "startup";
+    }>;
+    nativeEvent: z.ZodNullable<z.ZodString>;
+    state: z.ZodEnum<{
+        callable: "callable";
+        configured: "configured";
+        discovered: "discovered";
+        installed: "installed";
+        unknown: "unknown";
+        unsupported: "unsupported";
+        verified: "verified";
+    }>;
+    reason: z.ZodNullable<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>>;
+}, z.core.$strict>;
+export type HostCapability = z.infer<typeof hostCapabilitySchema>;
+export declare const hostCapabilitiesSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-capabilities/1">;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    surface: z.ZodEnum<{
+        "claude-hooks": "claude-hooks";
+        "codex-hooks": "codex-hooks";
+        "pi-extension": "pi-extension";
+    }>;
+    version: z.ZodNullable<z.ZodString>;
+    observedAt: z.ZodISODateTime;
+    executablePath: z.ZodNullable<z.ZodString>;
+    configPath: z.ZodNullable<z.ZodString>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        event: z.ZodEnum<{
+            "checkpoint-request": "checkpoint-request";
+            compact: "compact";
+            resume: "resume";
+            startup: "startup";
+        }>;
+        nativeEvent: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            callable: "callable";
+            configured: "configured";
+            discovered: "discovered";
+            installed: "installed";
+            unknown: "unknown";
+            unsupported: "unsupported";
+            verified: "verified";
+        }>;
+        reason: z.ZodNullable<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>>;
+    }, z.core.$strict>>;
+    reloadRequired: z.ZodBoolean;
+    trustRequired: z.ZodBoolean;
+    automaticHandoff: z.ZodEnum<{
+        manual: "manual";
+        unsupported: "unsupported";
+    }>;
+    limits: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type HostCapabilities = z.infer<typeof hostCapabilitiesSchema>;
+export declare const hostPlanFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    kind: z.ZodEnum<{
+        config: "config";
+        extension: "extension";
+        "hook-entry": "hook-entry";
+        manifest: "manifest";
+        skill: "skill";
+    }>;
+    operation: z.ZodEnum<{
+        conflict: "conflict";
+        create: "create";
+        "merge-managed": "merge-managed";
+        "replace-managed": "replace-managed";
+        unchanged: "unchanged";
+    }>;
+    beforeDigest: z.ZodNullable<z.ZodString>;
+    nextDigest: z.ZodString;
+}, z.core.$strict>;
+export type HostPlanFile = z.infer<typeof hostPlanFileSchema>;
+export declare const hostIntegrationPlanSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-integration/1">;
+    planId: z.ZodUUID;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    workspaceRoot: z.ZodString;
+    hostRoot: z.ZodString;
+    runtimeEntry: z.ZodString;
+    bundleDigest: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        kind: z.ZodEnum<{
+            config: "config";
+            extension: "extension";
+            "hook-entry": "hook-entry";
+            manifest: "manifest";
+            skill: "skill";
+        }>;
+        operation: z.ZodEnum<{
+            conflict: "conflict";
+            create: "create";
+            "merge-managed": "merge-managed";
+            "replace-managed": "replace-managed";
+            unchanged: "unchanged";
+        }>;
+        beforeDigest: z.ZodNullable<z.ZodString>;
+        nextDigest: z.ZodString;
+    }, z.core.$strict>>;
+    reloadRequired: z.ZodBoolean;
+    trustRequired: z.ZodBoolean;
+    diagnostics: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export type HostIntegrationPlan = z.infer<typeof hostIntegrationPlanSchema>;
+export declare const hostIntegrationResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-integration/1">;
+    ok: z.ZodBoolean;
+    status: z.ZodEnum<{
+        applied: "applied";
+        conflict: "conflict";
+        failed: "failed";
+        invalid: "invalid";
+        partial: "partial";
+        planned: "planned";
+        unchanged: "unchanged";
+        unsupported: "unsupported";
+    }>;
+    plan: z.ZodNullable<z.ZodObject<{
+        schema: z.ZodLiteral<"pappra/host-integration/1">;
+        planId: z.ZodUUID;
+        host: z.ZodEnum<{
+            claude: "claude";
+            codex: "codex";
+            pi: "pi";
+        }>;
+        workspaceRoot: z.ZodString;
+        hostRoot: z.ZodString;
+        runtimeEntry: z.ZodString;
+        bundleDigest: z.ZodString;
+        files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<{
+                config: "config";
+                extension: "extension";
+                "hook-entry": "hook-entry";
+                manifest: "manifest";
+                skill: "skill";
+            }>;
+            operation: z.ZodEnum<{
+                conflict: "conflict";
+                create: "create";
+                "merge-managed": "merge-managed";
+                "replace-managed": "replace-managed";
+                unchanged: "unchanged";
+            }>;
+            beforeDigest: z.ZodNullable<z.ZodString>;
+            nextDigest: z.ZodString;
+        }, z.core.$strict>>;
+        reloadRequired: z.ZodBoolean;
+        trustRequired: z.ZodBoolean;
+        diagnostics: z.ZodArray<z.ZodUnknown>;
+    }, z.core.$strict>>;
+    appliedFiles: z.ZodArray<z.ZodString>;
+    residualPaths: z.ZodArray<z.ZodString>;
+    diagnostics: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export type HostIntegrationResult = z.infer<typeof hostIntegrationResultSchema>;
+export declare const hostBundleFileSchema: z.ZodObject<{
+    path: z.ZodString;
+    digest: z.ZodString;
+    kind: z.ZodEnum<{
+        extension: "extension";
+        hook: "hook";
+        reference: "reference";
+        skill: "skill";
+    }>;
+}, z.core.$strict>;
+export type HostBundleFile = z.infer<typeof hostBundleFileSchema>;
+export declare const hostBundleSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-bundle/1">;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    skillId: z.ZodString;
+    packageVersion: z.ZodString;
+    bundleDigest: z.ZodString;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        kind: z.ZodEnum<{
+            extension: "extension";
+            hook: "hook";
+            reference: "reference";
+            skill: "skill";
+        }>;
+    }, z.core.$strict>>;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type HostBundle = z.infer<typeof hostBundleSchema>;
+/** Normalized event accepted by the local hook runtime. */
+export declare const hostHookInputSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-hook-input/1">;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    event: z.ZodEnum<{
+        "checkpoint-request": "checkpoint-request";
+        compact: "compact";
+        resume: "resume";
+        startup: "startup";
+    }>;
+    nativeEvent: z.ZodString;
+    eventId: z.ZodNullable<z.ZodString>;
+    sessionId: z.ZodNullable<z.ZodString>;
+    cwd: z.ZodString;
+    root: z.ZodNullable<z.ZodString>;
+    taskId: z.ZodNullable<z.ZodString>;
+    source: z.ZodNullable<z.ZodString>;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type HostHookInput = z.infer<typeof hostHookInputSchema>;
+export declare const hostHookResultSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-hook-result/1">;
+    ok: z.ZodBoolean;
+    status: z.ZodEnum<{
+        duplicate: "duplicate";
+        failed: "failed";
+        invalid: "invalid";
+        processed: "processed";
+        timeout: "timeout";
+        unsupported: "unsupported";
+    }>;
+    host: z.ZodNullable<z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>>;
+    event: z.ZodNullable<z.ZodEnum<{
+        "checkpoint-request": "checkpoint-request";
+        compact: "compact";
+        resume: "resume";
+        startup: "startup";
+    }>>;
+    eventKey: z.ZodNullable<z.ZodString>;
+    duplicate: z.ZodBoolean;
+    context: z.ZodNullable<z.ZodString>;
+    diagnostics: z.ZodArray<z.ZodUnknown>;
+}, z.core.$strict>;
+export type HostHookResult = z.infer<typeof hostHookResultSchema>;
+/** Observed external hook envelope; unknown keys are ignored by design. */
+export declare const commandHookEventSchema: z.ZodObject<{
+    hook_event_name: z.ZodString;
+    session_id: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodString;
+    source: z.ZodOptional<z.ZodString>;
+    event_id: z.ZodOptional<z.ZodString>;
+    pappra_task_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export type CommandHookEvent = z.infer<typeof commandHookEventSchema>;
+export declare const hostVerificationCheckSchema: z.ZodObject<{
+    id: z.ZodString;
+    status: z.ZodEnum<{
+        error: "error";
+        ok: "ok";
+        unknown: "unknown";
+        unsupported: "unsupported";
+        warning: "warning";
+    }>;
+    detail: z.ZodString;
+}, z.core.$strict>;
+export type HostVerificationCheck = z.infer<typeof hostVerificationCheckSchema>;
+export declare const hostVerificationSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-verification/1">;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    version: z.ZodNullable<z.ZodString>;
+    hostRoot: z.ZodString;
+    status: z.ZodEnum<{
+        conflict: "conflict";
+        partial: "partial";
+        unsupported: "unsupported";
+        verified: "verified";
+    }>;
+    bundleDigest: z.ZodNullable<z.ZodString>;
+    checks: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        status: z.ZodEnum<{
+            error: "error";
+            ok: "ok";
+            unknown: "unknown";
+            unsupported: "unsupported";
+            warning: "warning";
+        }>;
+        detail: z.ZodString;
+    }, z.core.$strict>>;
+    capabilities: z.ZodArray<z.ZodObject<{
+        event: z.ZodEnum<{
+            "checkpoint-request": "checkpoint-request";
+            compact: "compact";
+            resume: "resume";
+            startup: "startup";
+        }>;
+        nativeEvent: z.ZodNullable<z.ZodString>;
+        state: z.ZodEnum<{
+            callable: "callable";
+            configured: "configured";
+            discovered: "discovered";
+            installed: "installed";
+            unknown: "unknown";
+            unsupported: "unsupported";
+            verified: "verified";
+        }>;
+        reason: z.ZodNullable<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>>;
+    }, z.core.$strict>>;
+    diagnostics: z.ZodArray<z.ZodUnknown>;
+    residualPaths: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type HostVerification = z.infer<typeof hostVerificationSchema>;
+export declare const hostInstallManifestSchema: z.ZodObject<{
+    schema: z.ZodLiteral<"pappra/host-install/1">;
+    host: z.ZodEnum<{
+        claude: "claude";
+        codex: "codex";
+        pi: "pi";
+    }>;
+    packageVersion: z.ZodString;
+    bundleDigest: z.ZodString;
+    installedAt: z.ZodISODateTime;
+    hostRoot: z.ZodString;
+    runtimeEntry: z.ZodString;
+    configPath: z.ZodNullable<z.ZodString>;
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        digest: z.ZodString;
+        kind: z.ZodEnum<{
+            config: "config";
+            extension: "extension";
+            hook: "hook";
+            reference: "reference";
+            skill: "skill";
+        }>;
+    }, z.core.$strict>>;
+    reloadRequired: z.ZodBoolean;
+    trustRequired: z.ZodBoolean;
+}, z.core.$strict>;
+export type HostInstallManifest = z.infer<typeof hostInstallManifestSchema>;

package/dist/schemas/host.js

@@ -0,0 +1,201 @@
+import { z } from 'zod';
+import { evidenceRefSchema } from './evidence.js';
+export const HOST_INTEGRATION_SCHEMA = 'pappra/host-integration/1';
+export const HOST_CAPABILITIES_SCHEMA = 'pappra/host-capabilities/1';
+export const HOST_BUNDLE_SCHEMA = 'pappra/host-bundle/1';
+export const HOST_HOOK_INPUT_SCHEMA = 'pappra/host-hook-input/1';
+export const HOST_HOOK_RESULT_SCHEMA = 'pappra/host-hook-result/1';
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const digestOrNull = digestSchema.nullable();
+const absolutePathSchema = z
+    .string()
+    .min(1)
+    .max(4096)
+    .refine((value) => value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value), 'Expected an absolute host path.');
+export const hostNameSchema = z.enum(['pi', 'codex', 'claude']);
+export const hostLifecycleEventSchema = z.enum([
+    'startup',
+    'resume',
+    'compact',
+    'checkpoint-request',
+]);
+export const hostCapabilityStateSchema = z.enum([
+    'installed',
+    'configured',
+    'discovered',
+    'callable',
+    'verified',
+    'unsupported',
+    'unknown',
+]);
+export const hostCapabilitySchema = z.strictObject({
+    event: hostLifecycleEventSchema,
+    nativeEvent: z.string().min(1).max(128).nullable(),
+    state: hostCapabilityStateSchema,
+    reason: z.string().min(1).max(1024).nullable(),
+    evidence: z.array(evidenceRefSchema).max(8),
+});
+export const hostCapabilitiesSchema = z.strictObject({
+    schema: z.literal(HOST_CAPABILITIES_SCHEMA),
+    host: hostNameSchema,
+    surface: z.enum(['pi-extension', 'codex-hooks', 'claude-hooks']),
+    version: z.string().min(1).max(128).nullable(),
+    observedAt: z.iso.datetime({ offset: true }),
+    executablePath: absolutePathSchema.nullable(),
+    configPath: absolutePathSchema.nullable(),
+    capabilities: z.array(hostCapabilitySchema).max(8),
+    reloadRequired: z.boolean(),
+    trustRequired: z.boolean(),
+    automaticHandoff: z.enum(['unsupported', 'manual']),
+    limits: z.array(z.string().min(1).max(1024)).max(16),
+});
+export const hostPlanFileSchema = z.strictObject({
+    path: z
+        .string()
+        .min(1)
+        .max(2048)
+        .refine((value) => !value.startsWith('/') &&
+        !value.includes('\\') &&
+        !value.includes('\0') &&
+        !value.split('/').includes('..'), 'Expected a portable host-relative path.'),
+    kind: z.enum(['skill', 'hook-entry', 'extension', 'config', 'manifest']),
+    operation: z.enum([
+        'create',
+        'replace-managed',
+        'merge-managed',
+        'unchanged',
+        'conflict',
+    ]),
+    beforeDigest: digestOrNull,
+    nextDigest: digestSchema,
+});
+export const hostIntegrationPlanSchema = z.strictObject({
+    schema: z.literal(HOST_INTEGRATION_SCHEMA),
+    planId: z.uuid(),
+    host: hostNameSchema,
+    workspaceRoot: absolutePathSchema,
+    hostRoot: absolutePathSchema,
+    runtimeEntry: absolutePathSchema,
+    bundleDigest: digestSchema,
+    files: z.array(hostPlanFileSchema).max(64),
+    reloadRequired: z.boolean(),
+    trustRequired: z.boolean(),
+    diagnostics: z.array(z.unknown()).max(32),
+});
+export const hostIntegrationResultSchema = z.strictObject({
+    schema: z.literal(HOST_INTEGRATION_SCHEMA),
+    ok: z.boolean(),
+    status: z.enum([
+        'planned',
+        'applied',
+        'unchanged',
+        'partial',
+        'conflict',
+        'unsupported',
+        'invalid',
+        'failed',
+    ]),
+    plan: hostIntegrationPlanSchema.nullable(),
+    appliedFiles: z.array(z.string().min(1).max(2048)).max(64),
+    residualPaths: z.array(absolutePathSchema).max(32),
+    diagnostics: z.array(z.unknown()).max(32),
+});
+export const hostBundleFileSchema = z.strictObject({
+    path: z.string().min(1).max(2048),
+    digest: digestSchema,
+    kind: z.enum(['skill', 'reference', 'hook', 'extension']),
+});
+export const hostBundleSchema = z.strictObject({
+    schema: z.literal(HOST_BUNDLE_SCHEMA),
+    host: hostNameSchema,
+    skillId: z.string().min(1).max(128),
+    packageVersion: z.string().min(1).max(128),
+    bundleDigest: digestSchema,
+    files: z.array(hostBundleFileSchema).max(64),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+/** Normalized event accepted by the local hook runtime. */
+export const hostHookInputSchema = z.strictObject({
+    schema: z.literal(HOST_HOOK_INPUT_SCHEMA),
+    host: hostNameSchema,
+    event: hostLifecycleEventSchema,
+    nativeEvent: z.string().min(1).max(128),
+    eventId: z.string().min(1).max(256).nullable(),
+    sessionId: z.string().min(1).max(256).nullable(),
+    cwd: absolutePathSchema,
+    root: absolutePathSchema.nullable(),
+    taskId: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)
+        .nullable(),
+    source: z.string().min(1).max(128).nullable(),
+    observedAt: z.iso.datetime({ offset: true }),
+});
+export const hostHookResultSchema = z.strictObject({
+    schema: z.literal(HOST_HOOK_RESULT_SCHEMA),
+    ok: z.boolean(),
+    status: z.enum([
+        'processed',
+        'duplicate',
+        'unsupported',
+        'invalid',
+        'timeout',
+        'failed',
+    ]),
+    host: hostNameSchema.nullable(),
+    event: hostLifecycleEventSchema.nullable(),
+    eventKey: z.string().min(1).max(256).nullable(),
+    duplicate: z.boolean(),
+    context: z.string().max(8192).nullable(),
+    diagnostics: z.array(z.unknown()).max(16),
+});
+/** Observed external hook envelope; unknown keys are ignored by design. */
+export const commandHookEventSchema = z.looseObject({
+    hook_event_name: z.string().min(1).max(128),
+    session_id: z.string().min(1).max(256).optional(),
+    cwd: z.string().min(1).max(4096),
+    source: z.string().min(1).max(128).optional(),
+    event_id: z.string().min(1).max(256).optional(),
+    pappra_task_id: z
+        .string()
+        .min(1)
+        .max(64)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/)
+        .optional(),
+});
+export const hostVerificationCheckSchema = z.strictObject({
+    id: z.string().min(1).max(128),
+    status: z.enum(['ok', 'warning', 'error', 'unknown', 'unsupported']),
+    detail: z.string().min(1).max(2048),
+});
+export const hostVerificationSchema = z.strictObject({
+    schema: z.literal('pappra/host-verification/1'),
+    host: hostNameSchema,
+    version: z.string().min(1).max(128).nullable(),
+    hostRoot: absolutePathSchema,
+    status: z.enum(['verified', 'partial', 'unsupported', 'conflict']),
+    bundleDigest: digestOrNull,
+    checks: z.array(hostVerificationCheckSchema).max(32),
+    capabilities: z.array(hostCapabilitySchema).max(8),
+    diagnostics: z.array(z.unknown()).max(32),
+    residualPaths: z.array(absolutePathSchema).max(32),
+});
+export const hostInstallManifestSchema = z.strictObject({
+    schema: z.literal('pappra/host-install/1'),
+    host: hostNameSchema,
+    packageVersion: z.string().min(1).max(128),
+    bundleDigest: digestSchema,
+    installedAt: z.iso.datetime({ offset: true }),
+    hostRoot: absolutePathSchema,
+    runtimeEntry: absolutePathSchema,
+    configPath: z.string().min(1).max(2048).nullable(),
+    files: z.array(z.strictObject({
+        path: z.string().min(1).max(2048),
+        digest: digestSchema,
+        kind: z.enum(['skill', 'reference', 'hook', 'extension', 'config']),
+    })),
+    reloadRequired: z.boolean(),
+    trustRequired: z.boolean(),
+});

package/dist/schemas/index.d.ts

@@ -0,0 +1,15 @@
+export * from './diagnostics.js';
+export * from './continuity.js';
+export * from './code.js';
+export * from './collaboration.js';
+export * from './doctor.js';
+export * from './document.js';
+export * from './errors.js';
+export * from './evidence.js';
+export * from './host.js';
+export * from './init.js';
+export * from './install.js';
+export * from './machine.js';
+export * from './outcome.js';
+export * from './paths.js';
+export * from './workspace.js';

package/dist/schemas/index.js

@@ -0,0 +1,15 @@
+export * from './diagnostics.js';
+export * from './continuity.js';
+export * from './code.js';
+export * from './collaboration.js';
+export * from './doctor.js';
+export * from './document.js';
+export * from './errors.js';
+export * from './evidence.js';
+export * from './host.js';
+export * from './init.js';
+export * from './install.js';
+export * from './machine.js';
+export * from './outcome.js';
+export * from './paths.js';
+export * from './workspace.js';