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

package/dist/schemas/document.js

@@ -0,0 +1,296 @@
+import { z } from 'zod';
+import { isPortableRelativePath, normalizePortableRelativePath, } from './paths.js';
+export const DOCUMENT_SCHEMA = 'pappra/document/1';
+export const DOCUMENT_CATALOG_SCHEMA = 'pappra/document-catalog/1';
+export const DOCUMENT_WRITE_PROPOSAL_SCHEMA = 'pappra/document-write-proposal/1';
+export const KNOWLEDGE_DELETE_PLAN_SCHEMA = 'pappra/knowledge-delete-plan/1';
+export const KNOWLEDGE_LOCK_SCHEMA = 'pappra/knowledge-lock/1';
+export const KNOWLEDGE_JOURNAL_SCHEMA = 'pappra/knowledge-journal/1';
+const digestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/);
+const identifierSchema = z
+    .string()
+    .min(1)
+    .max(64)
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/);
+const documentPathSchema = z
+    .string()
+    .min(1)
+    .max(2048)
+    .refine((value) => value !== '.' &&
+    isPortableRelativePath(value) &&
+    normalizePortableRelativePath(value) === value, 'Use a normalized non-empty workspace-relative path without escaping the root.');
+export const documentKindSchema = z.enum([
+    'rule',
+    'architecture',
+    'decision',
+    'plan',
+    'research',
+    'review',
+    'delivery',
+    'checkpoint',
+    'generated',
+]);
+export const documentLifecycleSchema = z.enum([
+    'active',
+    'archived',
+    'superseded',
+]);
+export const documentMaturitySchema = z.enum(['draft', 'reviewed']);
+export const documentOwnerSchema = z.enum(['human', 'agent', 'generator']);
+export const documentVisibilitySchema = z.enum(['private', 'shareable']);
+export const documentLocationSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('workspace'),
+        path: documentPathSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('source'),
+        sourceId: identifierSchema,
+        path: documentPathSchema,
+    }),
+]);
+export const documentSourceSchema = z.discriminatedUnion('kind', [
+    z.strictObject({
+        kind: z.literal('document'),
+        documentId: z.uuid(),
+        digest: digestSchema,
+    }),
+    z.strictObject({
+        kind: z.literal('code'),
+        repositoryId: identifierSchema,
+        path: documentPathSchema,
+        version: z.string().min(1).max(256),
+    }),
+]);
+const documentRecordBaseSchema = z.strictObject({
+    schema: z.literal(DOCUMENT_SCHEMA),
+    documentId: z.uuid(),
+    location: documentLocationSchema,
+    kind: documentKindSchema,
+    lifecycle: documentLifecycleSchema,
+    maturity: documentMaturitySchema,
+    taskId: z.string().min(1).max(256).nullable(),
+    owner: documentOwnerSchema,
+    digest: digestSchema,
+    sources: z.array(documentSourceSchema).max(64),
+    supersededBy: z.uuid().nullable(),
+    lastReviewedAt: z.iso.datetime({ offset: true }).nullable(),
+    visibility: documentVisibilitySchema,
+});
+export const documentRecordSchema = documentRecordBaseSchema.superRefine((record, context) => {
+    if (record.lifecycle === 'superseded') {
+        if (record.supersededBy === null) {
+            context.addIssue({
+                code: 'custom',
+                path: ['supersededBy'],
+                message: 'A superseded document must name its replacement.',
+            });
+        }
+        else if (record.supersededBy === record.documentId) {
+            context.addIssue({
+                code: 'custom',
+                path: ['supersededBy'],
+                message: 'A document cannot supersede itself.',
+            });
+        }
+    }
+    else if (record.supersededBy !== null) {
+        context.addIssue({
+            code: 'custom',
+            path: ['supersededBy'],
+            message: 'Only a superseded document may name a replacement.',
+        });
+    }
+});
+export const documentCatalogSchema = z.strictObject({
+    schema: z.literal(DOCUMENT_CATALOG_SCHEMA),
+    workspaceId: z.uuid(),
+    updatedAt: z.iso.datetime({ offset: true }),
+    records: z.array(documentRecordSchema).max(2048),
+});
+const fileIdentitySchema = z.strictObject({
+    dev: z.number().int().nonnegative(),
+    ino: z.number().int().nonnegative(),
+});
+export const documentWriteProposalSchema = z
+    .strictObject({
+    schema: z.literal(DOCUMENT_WRITE_PROPOSAL_SCHEMA),
+    proposalId: z.uuid(),
+    createdAt: z.iso.datetime({ offset: true }),
+    mode: z.enum(['create', 'update']),
+    documentId: z.uuid(),
+    location: documentLocationSchema,
+    expectedDigest: digestSchema.nullable(),
+    nextDigest: digestSchema,
+    catalogDigest: digestSchema,
+    rootIdentity: fileIdentitySchema,
+    record: documentRecordSchema,
+    diff: z.string().max(4 * 1024 * 1024),
+})
+    .superRefine((proposal, context) => {
+    if (proposal.documentId !== proposal.record.documentId ||
+        JSON.stringify(proposal.location) !==
+            JSON.stringify(proposal.record.location) ||
+        proposal.nextDigest !== proposal.record.digest) {
+        context.addIssue({
+            code: 'custom',
+            path: ['record'],
+            message: 'Proposal identity/location/digest must match its record.',
+        });
+    }
+    if (proposal.mode === 'create') {
+        if (proposal.expectedDigest !== null) {
+            context.addIssue({
+                code: 'custom',
+                path: ['expectedDigest'],
+                message: 'A create proposal must have expectedDigest=null.',
+            });
+        }
+        if (proposal.record.lifecycle !== 'active' ||
+            proposal.record.supersededBy !== null) {
+            context.addIssue({
+                code: 'custom',
+                path: ['record'],
+                message: 'A new document record must be active and not superseded.',
+            });
+        }
+    }
+    else if (proposal.expectedDigest === null) {
+        context.addIssue({
+            code: 'custom',
+            path: ['expectedDigest'],
+            message: 'An update proposal must bind the current expectedDigest.',
+        });
+    }
+});
+export const knowledgeDeleteBlockerSchema = z.strictObject({
+    code: z.string().min(1).max(128),
+    message: z.string().min(1).max(1024),
+});
+export const knowledgeDeleteReferenceSchema = z.strictObject({
+    documentId: z.uuid(),
+    relation: z.enum(['source', 'superseded-by']),
+});
+export const knowledgeDeletePlanSchema = z.strictObject({
+    schema: z.literal(KNOWLEDGE_DELETE_PLAN_SCHEMA),
+    planId: z.uuid(),
+    createdAt: z.iso.datetime({ offset: true }),
+    documentId: z.uuid(),
+    removeFile: z.boolean(),
+    location: documentLocationSchema,
+    expectedFileDigest: digestSchema.nullable(),
+    expectedFileIdentity: fileIdentitySchema.nullable(),
+    catalogScope: z.enum(['shared', 'private']),
+    catalogDigest: digestSchema,
+    rootIdentity: fileIdentitySchema,
+    references: z.array(knowledgeDeleteReferenceSchema).max(128),
+    pathReferences: z.literal('unchecked'),
+    coverage: z.literal('catalog-only'),
+    taskState: z.enum(['not-linked', 'unknown']),
+    blockers: z.array(knowledgeDeleteBlockerSchema).max(32),
+    deletable: z.boolean(),
+});
+export const knowledgeOperationSchema = z.enum([
+    'write-document',
+    'archive-document',
+    'supersede-document',
+    'delete-document',
+    'share-document',
+]);
+export const knowledgeLockSchema = z.strictObject({
+    schema: z.literal(KNOWLEDGE_LOCK_SCHEMA),
+    token: z.uuid(),
+    operation: knowledgeOperationSchema,
+    pid: z.number().int().positive(),
+    createdAt: z.iso.datetime({ offset: true }),
+});
+export const knowledgeJournalSchema = z.strictObject({
+    schema: z.literal(KNOWLEDGE_JOURNAL_SCHEMA),
+    operationId: z.uuid(),
+    operation: knowledgeOperationSchema,
+    stage: z.enum([
+        'prepared',
+        'file-written',
+        'catalog-written',
+        'file-removed',
+        'complete',
+        'failed',
+    ]),
+    documentId: z.uuid().nullable(),
+    targetPath: z.string().min(1).max(4096).nullable(),
+    catalogScope: z.enum(['shared', 'private']).nullable(),
+    expectedDigest: digestSchema.nullable(),
+    fileDigest: digestSchema.nullable(),
+    catalogDigest: digestSchema.nullable(),
+    createdAt: z.iso.datetime({ offset: true }),
+    updatedAt: z.iso.datetime({ offset: true }),
+    residualPaths: z.array(z.string().min(1).max(4096)).max(64),
+    detail: z.string().max(4096).nullable(),
+});
+export const knowledgeDiagnosticSchema = z.strictObject({
+    code: z.string().min(1).max(128),
+    severity: z.enum(['error', 'warning', 'info']),
+    message: z.string().min(1).max(4096),
+    source: z.string().min(1).max(4096),
+    pointer: z.string().max(2048).nullable(),
+    hint: z.string().max(4096).nullable(),
+});
+export const docsListReportSchema = z.strictObject({
+    schema: z.literal('pappra/docs-list/1'),
+    ok: z.boolean(),
+    includePrivate: z.boolean(),
+    includeArchived: z.boolean(),
+    catalogDigest: z.string(),
+    documents: z.array(documentRecordSchema).max(2048),
+    diagnostics: z.array(knowledgeDiagnosticSchema).max(2048),
+});
+export const documentCheckEntrySchema = z.strictObject({
+    documentId: z.uuid(),
+    scope: z.enum(['shared', 'private']),
+    lifecycle: documentLifecycleSchema,
+    maturity: documentMaturitySchema,
+    fileDigest: digestSchema.nullable(),
+    recordDigest: digestSchema,
+    freshness: z.enum(['current', 'needs-review', 'unknown']),
+    reasons: z
+        .array(z.strictObject({
+        code: z.string().min(1).max(128),
+        message: z.string().min(1).max(4096),
+    }))
+        .max(128),
+    sourceChecks: z
+        .array(z.strictObject({
+        kind: z.enum(['document', 'code']),
+        ref: z.string().min(1).max(4096),
+        status: z.enum(['current', 'needs-review', 'unknown']),
+        message: z.string().min(1).max(4096),
+    }))
+        .max(128),
+});
+export const docsCheckReportSchema = z.strictObject({
+    schema: z.literal('pappra/docs-check/1'),
+    ok: z.boolean(),
+    checkedAt: z.iso.datetime({ offset: true }),
+    catalogDigest: z.string(),
+    entries: z.array(documentCheckEntrySchema).max(2048),
+    diagnostics: z.array(knowledgeDiagnosticSchema).max(2048),
+    summary: z.strictObject({
+        total: z.number().int().nonnegative(),
+        current: z.number().int().nonnegative(),
+        needsReview: z.number().int().nonnegative(),
+        unknown: z.number().int().nonnegative(),
+    }),
+    coverage: z.strictObject({
+        catalogs: z.enum(['shared', 'shared-and-private']),
+        pathReferences: z.literal('unchecked'),
+        repositoryContent: z.literal('not-scanned'),
+        taskExecution: z.literal('unknown'),
+    }),
+});
+export const docsArchiveReportSchema = z.strictObject({
+    schema: z.literal('pappra/docs-archive/1'),
+    ok: z.boolean(),
+    status: z.string().min(1).max(64),
+    document: documentRecordSchema.nullable(),
+    diagnostics: z.array(knowledgeDiagnosticSchema).max(2048),
+});

package/dist/schemas/errors.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Stable diagnostic and rejection codes.
+ *
+ * These values are part of the persisted and machine-readable interface:
+ * never rename an existing entry. Add a new code instead.
+ */
+export declare const diagnosticCodes: {
+    readonly fileNotFound: 'file_not_found';
+    readonly fileUnreadable: 'file_unreadable';
+    readonly fileTooLarge: 'file_too_large';
+    readonly fileNotRegular: 'file_not_regular';
+    readonly documentPathEscapesRoot: 'document_path_escapes_root';
+    readonly initInputRequired: 'init_input_required';
+    readonly initInvalidInput: 'init_invalid_input';
+    readonly initNoTty: 'init_no_tty';
+    readonly initRegisteredRootUsed: 'init_registered_root_used';
+    readonly initExistingConfigReused: 'init_existing_config_reused';
+    readonly initPlanStale: 'init_plan_stale';
+    readonly initPlanInvalid: 'init_plan_invalid';
+    readonly initTargetExists: 'init_target_exists';
+    readonly initTargetUnsafe: 'init_target_unsafe';
+    readonly initRepositoryUnknown: 'init_repository_unknown';
+    readonly initRepositoryDuplicate: 'init_repository_duplicate';
+    readonly initKnowledgeUnknown: 'init_knowledge_unknown';
+    readonly initValidationUnknown: 'init_validation_unknown';
+    readonly initValidationUnbound: 'init_validation_unbound';
+    readonly initExternalMappingRequired: 'init_external_mapping_required';
+    readonly initApplyUnsupported: 'init_apply_unsupported';
+    readonly initApplyFailed: 'init_apply_failed';
+    readonly initApplyResidual: 'init_apply_residual';
+    readonly initRuntimeSourceRequired: 'init_runtime_source_required';
+    readonly initCancelled: 'init_cancelled';
+    readonly fileInvalidEncoding: 'file_invalid_encoding';
+    readonly configMissing: 'config_missing';
+    readonly configSymlinkEscape: 'config_symlink_escape';
+    readonly configInvalidJson: 'config_invalid_json';
+    readonly configUnsupportedSchema: 'config_unsupported_schema';
+    readonly configUnknownKey: 'config_unknown_key';
+    readonly configSchemaInvalid: 'config_schema_invalid';
+    readonly configDuplicateRepositoryId: 'config_duplicate_repository_id';
+    readonly configDuplicateValidationId: 'config_duplicate_validation_id';
+    readonly configUnknownRepository: 'config_unknown_repository';
+    readonly configPathInvalid: 'config_path_invalid';
+    readonly configPathAbsolute: 'config_path_absolute';
+    readonly configPathEscapesRoot: 'config_path_escapes_root';
+    readonly configGlobNotSupported: 'config_glob_not_supported';
+    readonly machineWorkspaceMismatch: 'machine_workspace_mismatch';
+    readonly machineExternalDuplicate: 'machine_external_duplicate';
+    readonly machineExternalPathInvalid: 'machine_external_path_invalid';
+    readonly runtimeMissing: 'runtime_missing';
+    readonly runtimeVersionMismatch: 'runtime_version_mismatch';
+    readonly workspaceStartInvalid: 'workspace_start_invalid';
+    readonly workspaceRootInvalid: 'workspace_root_invalid';
+    readonly workspaceNotFound: 'workspace_not_found';
+    readonly workspaceRegistrationIncomplete: 'workspace_registration_incomplete';
+    readonly repositoryPathMissing: 'repository_path_missing';
+    readonly repositoryNotGit: 'repository_not_git';
+    readonly repositorySymlinkEscape: 'repository_symlink_escape';
+    readonly repositoryNestedWorkspace: 'repository_nested_workspace';
+    readonly repositoryDuplicatePath: 'repository_duplicate_path';
+    readonly externalRepositoryUnmapped: 'external_repository_unmapped';
+    readonly externalRepositoryInvalid: 'external_repository_invalid';
+    readonly knowledgeSourceMissing: 'knowledge_source_missing';
+    readonly knowledgeSourceSymlinkEscape: 'knowledge_source_symlink_escape';
+    readonly knowledgeSourceNotReadable: 'knowledge_source_not_readable';
+    readonly documentIgnored: 'document_ignored';
+    readonly discoverySymlinkSkipped: 'discovery_symlink_skipped';
+    readonly discoveryLimitReached: 'discovery_limit_reached';
+    readonly discoveryNestedWorkspace: 'discovery_nested_workspace';
+    readonly ignoreFilterUnavailable: 'ignore_filter_unavailable';
+    readonly packageManifestInvalid: 'package_manifest_invalid';
+    readonly validationRunnerUnsupported: 'validation_runner_unsupported';
+    readonly validationRunnerAmbiguous: 'validation_runner_ambiguous';
+    readonly validationCandidateUnbound: 'validation_candidate_unbound';
+    readonly gitUnavailable: 'git_unavailable';
+    readonly gitCommandFailed: 'git_command_failed';
+    readonly gitTimeout: 'git_timeout';
+    readonly gitOutputLimit: 'git_output_limit';
+    readonly gitAborted: 'git_aborted';
+    readonly doctor_workspace_registered: 'doctor_workspace_registered';
+    readonly doctor_workspace_not_registered: 'doctor_workspace_not_registered';
+    readonly doctor_config_valid: 'doctor_config_valid';
+    readonly doctor_machine_valid: 'doctor_machine_valid';
+    readonly doctor_repository_ok: 'doctor_repository_ok';
+    readonly doctor_knowledge_ok: 'doctor_knowledge_ok';
+    readonly doctor_install_ok: 'doctor_install_ok';
+    readonly doctor_install_unknown: 'doctor_install_unknown';
+    readonly doctor_tool_disabled: 'doctor_tool_disabled';
+    readonly doctor_workspace_incomplete: 'doctor_workspace_incomplete';
+    readonly doctor_workspace_unavailable: 'doctor_workspace_unavailable';
+    readonly doctor_config_missing: 'doctor_config_missing';
+    readonly doctor_config_invalid: 'doctor_config_invalid';
+    readonly doctor_machine_invalid: 'doctor_machine_invalid';
+    readonly doctor_repository_issues: 'doctor_repository_issues';
+    readonly doctor_knowledge_issues: 'doctor_knowledge_issues';
+    readonly doctor_validation_unverified: 'doctor_validation_unverified';
+    readonly doctor_install_state_invalid: 'doctor_install_state_invalid';
+    readonly doctor_install_lock: 'doctor_install_lock';
+    readonly doctor_install_partial: 'doctor_install_partial';
+    readonly doctor_install_modified: 'doctor_install_modified';
+    readonly doctor_install_backup_missing: 'doctor_install_backup_missing';
+    readonly doctor_runtime_missing: 'doctor_runtime_missing';
+    readonly doctor_runtime_mismatch: 'doctor_runtime_mismatch';
+    readonly doctor_runtime_unverified: 'doctor_runtime_unverified';
+    readonly doctor_runtime_locked: 'doctor_runtime_locked';
+    readonly doctor_runtime_partial: 'doctor_runtime_partial';
+    readonly doctor_runtime_corrupt: 'doctor_runtime_corrupt';
+    readonly doctor_runtime_unknown: 'doctor_runtime_unknown';
+    readonly doctor_host_missing: 'doctor_host_missing';
+    readonly doctor_host_discovered_unverified: 'doctor_host_discovered_unverified';
+    readonly doctor_host_config_present: 'doctor_host_config_present';
+    readonly doctor_host_integration_unsupported: 'doctor_host_integration_unsupported';
+    readonly doctor_skill_verification_unsupported: 'doctor_skill_verification_unsupported';
+    readonly doctor_tool_preference_unavailable: 'doctor_tool_preference_unavailable';
+    readonly doctor_tool_discovered_unverified: 'doctor_tool_discovered_unverified';
+    readonly doctor_references_incomplete: 'doctor_references_incomplete';
+    readonly doctor_read_error: 'doctor_read_error';
+    readonly doctor_failed: 'doctor_failed';
+    readonly document_catalog_invalid: 'document_catalog_invalid';
+    readonly document_catalog_unsupported: 'document_catalog_unsupported';
+    readonly document_catalog_conflict: 'document_catalog_conflict';
+    readonly document_record_invalid: 'document_record_invalid';
+    readonly document_not_found: 'document_not_found';
+    readonly document_already_registered: 'document_already_registered';
+    readonly document_duplicate_id: 'document_duplicate_id';
+    readonly document_location_conflict: 'document_location_conflict';
+    readonly document_path_unsafe: 'document_path_unsafe';
+    readonly document_nested_workspace: 'document_nested_workspace';
+    readonly document_access_denied: 'document_access_denied';
+    readonly document_source_invalid: 'document_source_invalid';
+    readonly document_file_changed: 'document_file_changed';
+    readonly document_write_conflict: 'document_write_conflict';
+    readonly document_proposal_stale: 'document_proposal_stale';
+    readonly document_write_partial: 'document_write_partial';
+    readonly document_generated_modified: 'document_generated_modified';
+    readonly document_delete_blocked: 'document_delete_blocked';
+    readonly document_delete_stale: 'document_delete_stale';
+    readonly document_supersede_invalid: 'document_supersede_invalid';
+    readonly document_visibility_invalid: 'document_visibility_invalid';
+    readonly document_task_state_unknown: 'document_task_state_unknown';
+    readonly document_locked: 'document_locked';
+    readonly document_journal_failed: 'document_journal_failed';
+    readonly code_repository_required: 'code_repository_required';
+    readonly code_repository_unknown: 'code_repository_unknown';
+    readonly code_identity_changed: 'code_identity_changed';
+    readonly code_working_tree_partial: 'code_working_tree_partial';
+    readonly code_engine_unavailable: 'code_engine_unavailable';
+    readonly code_engine_failed: 'code_engine_failed';
+    readonly code_index_missing: 'code_index_missing';
+    readonly code_index_stale: 'code_index_stale';
+    readonly code_index_partial: 'code_index_partial';
+    readonly code_index_unsupported: 'code_index_unsupported';
+    readonly code_prepare_conflict: 'code_prepare_conflict';
+    readonly code_prepare_failed: 'code_prepare_failed';
+    readonly code_prepare_partial: 'code_prepare_partial';
+    readonly code_registration_invalid: 'code_registration_invalid';
+    readonly code_query_unsupported: 'code_query_unsupported';
+    readonly code_query_invalid: 'code_query_invalid';
+    readonly code_output_limit: 'code_output_limit';
+    readonly code_path_unsafe: 'code_path_unsafe';
+    readonly host_unavailable: 'host_unavailable';
+    readonly host_version_unsupported: 'host_version_unsupported';
+    readonly host_capability_unknown: 'host_capability_unknown';
+    readonly host_install_conflict: 'host_install_conflict';
+    readonly host_install_unsafe: 'host_install_unsafe';
+    readonly host_install_partial: 'host_install_partial';
+    readonly host_config_invalid: 'host_config_invalid';
+    readonly host_bundle_invalid: 'host_bundle_invalid';
+    readonly host_bundle_stale: 'host_bundle_stale';
+    readonly host_verify_failed: 'host_verify_failed';
+    readonly host_hook_input_invalid: 'host_hook_input_invalid';
+    readonly host_hook_cwd_invalid: 'host_hook_cwd_invalid';
+    readonly host_hook_unsupported: 'host_hook_unsupported';
+    readonly host_hook_timeout: 'host_hook_timeout';
+    readonly host_hook_failed: 'host_hook_failed';
+};
+export type DiagnosticCode = (typeof diagnosticCodes)[keyof typeof diagnosticCodes];

package/dist/schemas/errors.js

@@ -0,0 +1,176 @@
+/**
+ * Stable diagnostic and rejection codes.
+ *
+ * These values are part of the persisted and machine-readable interface:
+ * never rename an existing entry. Add a new code instead.
+ */
+export const diagnosticCodes = {
+    fileNotFound: 'file_not_found',
+    fileUnreadable: 'file_unreadable',
+    fileTooLarge: 'file_too_large',
+    fileNotRegular: 'file_not_regular',
+    documentPathEscapesRoot: 'document_path_escapes_root',
+    initInputRequired: 'init_input_required',
+    initInvalidInput: 'init_invalid_input',
+    initNoTty: 'init_no_tty',
+    initRegisteredRootUsed: 'init_registered_root_used',
+    initExistingConfigReused: 'init_existing_config_reused',
+    initPlanStale: 'init_plan_stale',
+    initPlanInvalid: 'init_plan_invalid',
+    initTargetExists: 'init_target_exists',
+    initTargetUnsafe: 'init_target_unsafe',
+    initRepositoryUnknown: 'init_repository_unknown',
+    initRepositoryDuplicate: 'init_repository_duplicate',
+    initKnowledgeUnknown: 'init_knowledge_unknown',
+    initValidationUnknown: 'init_validation_unknown',
+    initValidationUnbound: 'init_validation_unbound',
+    initExternalMappingRequired: 'init_external_mapping_required',
+    initApplyUnsupported: 'init_apply_unsupported',
+    initApplyFailed: 'init_apply_failed',
+    initApplyResidual: 'init_apply_residual',
+    initRuntimeSourceRequired: 'init_runtime_source_required',
+    initCancelled: 'init_cancelled',
+    fileInvalidEncoding: 'file_invalid_encoding',
+    configMissing: 'config_missing',
+    configSymlinkEscape: 'config_symlink_escape',
+    configInvalidJson: 'config_invalid_json',
+    configUnsupportedSchema: 'config_unsupported_schema',
+    configUnknownKey: 'config_unknown_key',
+    configSchemaInvalid: 'config_schema_invalid',
+    configDuplicateRepositoryId: 'config_duplicate_repository_id',
+    configDuplicateValidationId: 'config_duplicate_validation_id',
+    configUnknownRepository: 'config_unknown_repository',
+    configPathInvalid: 'config_path_invalid',
+    configPathAbsolute: 'config_path_absolute',
+    configPathEscapesRoot: 'config_path_escapes_root',
+    configGlobNotSupported: 'config_glob_not_supported',
+    machineWorkspaceMismatch: 'machine_workspace_mismatch',
+    machineExternalDuplicate: 'machine_external_duplicate',
+    machineExternalPathInvalid: 'machine_external_path_invalid',
+    runtimeMissing: 'runtime_missing',
+    runtimeVersionMismatch: 'runtime_version_mismatch',
+    workspaceStartInvalid: 'workspace_start_invalid',
+    workspaceRootInvalid: 'workspace_root_invalid',
+    workspaceNotFound: 'workspace_not_found',
+    workspaceRegistrationIncomplete: 'workspace_registration_incomplete',
+    repositoryPathMissing: 'repository_path_missing',
+    repositoryNotGit: 'repository_not_git',
+    repositorySymlinkEscape: 'repository_symlink_escape',
+    repositoryNestedWorkspace: 'repository_nested_workspace',
+    repositoryDuplicatePath: 'repository_duplicate_path',
+    externalRepositoryUnmapped: 'external_repository_unmapped',
+    externalRepositoryInvalid: 'external_repository_invalid',
+    knowledgeSourceMissing: 'knowledge_source_missing',
+    knowledgeSourceSymlinkEscape: 'knowledge_source_symlink_escape',
+    knowledgeSourceNotReadable: 'knowledge_source_not_readable',
+    documentIgnored: 'document_ignored',
+    discoverySymlinkSkipped: 'discovery_symlink_skipped',
+    discoveryLimitReached: 'discovery_limit_reached',
+    discoveryNestedWorkspace: 'discovery_nested_workspace',
+    ignoreFilterUnavailable: 'ignore_filter_unavailable',
+    packageManifestInvalid: 'package_manifest_invalid',
+    validationRunnerUnsupported: 'validation_runner_unsupported',
+    validationRunnerAmbiguous: 'validation_runner_ambiguous',
+    validationCandidateUnbound: 'validation_candidate_unbound',
+    gitUnavailable: 'git_unavailable',
+    gitCommandFailed: 'git_command_failed',
+    gitTimeout: 'git_timeout',
+    gitOutputLimit: 'git_output_limit',
+    gitAborted: 'git_aborted',
+    doctor_workspace_registered: 'doctor_workspace_registered',
+    doctor_workspace_not_registered: 'doctor_workspace_not_registered',
+    doctor_config_valid: 'doctor_config_valid',
+    doctor_machine_valid: 'doctor_machine_valid',
+    doctor_repository_ok: 'doctor_repository_ok',
+    doctor_knowledge_ok: 'doctor_knowledge_ok',
+    doctor_install_ok: 'doctor_install_ok',
+    doctor_install_unknown: 'doctor_install_unknown',
+    doctor_tool_disabled: 'doctor_tool_disabled',
+    doctor_workspace_incomplete: 'doctor_workspace_incomplete',
+    doctor_workspace_unavailable: 'doctor_workspace_unavailable',
+    doctor_config_missing: 'doctor_config_missing',
+    doctor_config_invalid: 'doctor_config_invalid',
+    doctor_machine_invalid: 'doctor_machine_invalid',
+    doctor_repository_issues: 'doctor_repository_issues',
+    doctor_knowledge_issues: 'doctor_knowledge_issues',
+    doctor_validation_unverified: 'doctor_validation_unverified',
+    doctor_install_state_invalid: 'doctor_install_state_invalid',
+    doctor_install_lock: 'doctor_install_lock',
+    doctor_install_partial: 'doctor_install_partial',
+    doctor_install_modified: 'doctor_install_modified',
+    doctor_install_backup_missing: 'doctor_install_backup_missing',
+    doctor_runtime_missing: 'doctor_runtime_missing',
+    doctor_runtime_mismatch: 'doctor_runtime_mismatch',
+    doctor_runtime_unverified: 'doctor_runtime_unverified',
+    doctor_runtime_locked: 'doctor_runtime_locked',
+    doctor_runtime_partial: 'doctor_runtime_partial',
+    doctor_runtime_corrupt: 'doctor_runtime_corrupt',
+    doctor_runtime_unknown: 'doctor_runtime_unknown',
+    doctor_host_missing: 'doctor_host_missing',
+    doctor_host_discovered_unverified: 'doctor_host_discovered_unverified',
+    doctor_host_config_present: 'doctor_host_config_present',
+    doctor_host_integration_unsupported: 'doctor_host_integration_unsupported',
+    doctor_skill_verification_unsupported: 'doctor_skill_verification_unsupported',
+    doctor_tool_preference_unavailable: 'doctor_tool_preference_unavailable',
+    doctor_tool_discovered_unverified: 'doctor_tool_discovered_unverified',
+    doctor_references_incomplete: 'doctor_references_incomplete',
+    doctor_read_error: 'doctor_read_error',
+    doctor_failed: 'doctor_failed',
+    document_catalog_invalid: 'document_catalog_invalid',
+    document_catalog_unsupported: 'document_catalog_unsupported',
+    document_catalog_conflict: 'document_catalog_conflict',
+    document_record_invalid: 'document_record_invalid',
+    document_not_found: 'document_not_found',
+    document_already_registered: 'document_already_registered',
+    document_duplicate_id: 'document_duplicate_id',
+    document_location_conflict: 'document_location_conflict',
+    document_path_unsafe: 'document_path_unsafe',
+    document_nested_workspace: 'document_nested_workspace',
+    document_access_denied: 'document_access_denied',
+    document_source_invalid: 'document_source_invalid',
+    document_file_changed: 'document_file_changed',
+    document_write_conflict: 'document_write_conflict',
+    document_proposal_stale: 'document_proposal_stale',
+    document_write_partial: 'document_write_partial',
+    document_generated_modified: 'document_generated_modified',
+    document_delete_blocked: 'document_delete_blocked',
+    document_delete_stale: 'document_delete_stale',
+    document_supersede_invalid: 'document_supersede_invalid',
+    document_visibility_invalid: 'document_visibility_invalid',
+    document_task_state_unknown: 'document_task_state_unknown',
+    document_locked: 'document_locked',
+    document_journal_failed: 'document_journal_failed',
+    code_repository_required: 'code_repository_required',
+    code_repository_unknown: 'code_repository_unknown',
+    code_identity_changed: 'code_identity_changed',
+    code_working_tree_partial: 'code_working_tree_partial',
+    code_engine_unavailable: 'code_engine_unavailable',
+    code_engine_failed: 'code_engine_failed',
+    code_index_missing: 'code_index_missing',
+    code_index_stale: 'code_index_stale',
+    code_index_partial: 'code_index_partial',
+    code_index_unsupported: 'code_index_unsupported',
+    code_prepare_conflict: 'code_prepare_conflict',
+    code_prepare_failed: 'code_prepare_failed',
+    code_prepare_partial: 'code_prepare_partial',
+    code_registration_invalid: 'code_registration_invalid',
+    code_query_unsupported: 'code_query_unsupported',
+    code_query_invalid: 'code_query_invalid',
+    code_output_limit: 'code_output_limit',
+    code_path_unsafe: 'code_path_unsafe',
+    host_unavailable: 'host_unavailable',
+    host_version_unsupported: 'host_version_unsupported',
+    host_capability_unknown: 'host_capability_unknown',
+    host_install_conflict: 'host_install_conflict',
+    host_install_unsafe: 'host_install_unsafe',
+    host_install_partial: 'host_install_partial',
+    host_config_invalid: 'host_config_invalid',
+    host_bundle_invalid: 'host_bundle_invalid',
+    host_bundle_stale: 'host_bundle_stale',
+    host_verify_failed: 'host_verify_failed',
+    host_hook_input_invalid: 'host_hook_input_invalid',
+    host_hook_cwd_invalid: 'host_hook_cwd_invalid',
+    host_hook_unsupported: 'host_hook_unsupported',
+    host_hook_timeout: 'host_hook_timeout',
+    host_hook_failed: 'host_hook_failed',
+};

package/dist/schemas/evidence.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const evidenceScopeSchema: z.ZodEnum<{
+    declared: "declared";
+    "live-owned": "live-owned";
+    persisted: "persisted";
+}>;
+export declare const evidenceRefSchema: 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>;
+export type EvidenceRef = z.infer<typeof evidenceRefSchema>;
+export type EvidenceScope = z.infer<typeof evidenceScopeSchema>;