@auden.to/protocol 0.1.0-alpha.2

package/dist/schemas.test.js

@@ -0,0 +1,963 @@
+import { ValiError } from 'valibot';
+import { describe, it, expect } from 'vitest';
+import { MAX_ACTION_METADATA_BYTES, MAX_CONTEXT_CONTENT_BYTES, MAX_TRANSFORM_SOURCE_IDS, MAX_INBOX_ARCHIVE_BATCH, MAX_RAW_GUIDE_CONTENT_BYTES, MAX_RULE_DELETIONS_BATCH, MAX_RULES_IMPORT_BATCH, MAX_SKILL_MEMBER_FILES, MAX_SYNC_ACTIONS_BATCH, MAX_SYNC_AUX_BATCH, parseActionEntry, parseAgentConfig, parseBundle, parseBundleListResponse, parseCliTokenMetadata, parseContextItem, parseContextItemsResponse, parseCreateBundleRequest, parseCreateBundleResponse, parseInboxArchiveRequest, parseInboxCaptureRequest, parseInboxListResponse, parsePushContextRequest, parsePushContextResponse, parseUpdateContextItemRequest, parseDashboardSyncRequest, parseEvalProviderConfig, parseEvalProviderSettings, parseExtractedFeedbackBatch, parseExtractedGuideSuggestion, parseExtractedSkillSuggestion, parseEvalResult, parseGuideBundleResponse, parseNormalizedGuide, parseRawGuideFilePayload, parseGuideMemberFilesResponse, parseRuleDeletionsRequest, parseRulesImportRequest, parseGuideSnapshot, parseProposalCitation, parseProjectionRequest, parseProjectionResult, parseRuleVerdict, parseRunEvalResult, parseValidateTokenRequest, parseValidateTokenResponse, } from './schemas.js';
+// Helper: assert that parse throws a ValiError (not some other error)
+function expectValiError(fn) {
+    expect(fn).toThrow(ValiError);
+}
+describe('parseAgentConfig', () => {
+    it('accepts a valid agent config', () => {
+        const config = {
+            id: 'agent-1',
+            name: 'Test Agent',
+            description: 'A test agent',
+            capabilities: ['read', 'write'],
+        };
+        expect(parseAgentConfig(config)).toEqual(config);
+    });
+    it('throws ValiError when id is missing', () => {
+        expectValiError(() => parseAgentConfig({ name: 'x', description: 'y', capabilities: [] }));
+    });
+    it('throws ValiError when capabilities contains non-string', () => {
+        expectValiError(() => parseAgentConfig({ id: '1', name: 'x', description: 'y', capabilities: [42] }));
+    });
+    it('accepts optional meta field', () => {
+        const config = {
+            id: 'a',
+            name: 'n',
+            description: 'd',
+            capabilities: [],
+            meta: { key: 'value' },
+        };
+        expect(parseAgentConfig(config)).toEqual(config);
+    });
+});
+describe('parseEvalResult', () => {
+    it('accepts a valid eval result', () => {
+        const result = {
+            agentId: 'agent-1',
+            passed: true,
+            summary: 'All checks passed',
+            findings: [{ level: 'info', message: 'OK' }],
+        };
+        expect(parseEvalResult(result)).toEqual(result);
+    });
+    it('throws ValiError when passed is not boolean', () => {
+        expectValiError(() => parseEvalResult({ agentId: '1', passed: 'yes', summary: 'x', findings: [] }));
+    });
+    it('throws ValiError when findings contains invalid level', () => {
+        expectValiError(() => parseEvalResult({
+            agentId: '1',
+            passed: true,
+            summary: 'x',
+            findings: [{ level: 'debug', message: 'x' }],
+        }));
+    });
+});
+describe('parseEvalProviderSettings', () => {
+    it('accepts partial settings', () => {
+        const settings = {
+            provider: 'openrouter',
+            model: 'anthropic/claude-sonnet-4.6',
+        };
+        expect(parseEvalProviderSettings(settings)).toEqual(settings);
+    });
+    it('rejects unknown providers', () => {
+        expectValiError(() => parseEvalProviderSettings({ provider: 'bedrock' }));
+    });
+});
+describe('parseEvalProviderConfig', () => {
+    it('accepts a complete runtime config', () => {
+        const config = {
+            provider: 'anthropic',
+            model: 'claude-sonnet-4-6',
+            apiKey: 'sk-ant-test',
+            baseUrl: 'https://api.anthropic.com',
+        };
+        expect(parseEvalProviderConfig(config)).toEqual(config);
+    });
+    it('requires model', () => {
+        expectValiError(() => parseEvalProviderConfig({ provider: 'openrouter' }));
+    });
+});
+describe('parseValidateTokenRequest', () => {
+    it('accepts valid input', () => {
+        expect(parseValidateTokenRequest({ token: 'tok_abc' })).toEqual({ token: 'tok_abc' });
+    });
+    it('throws ValiError when token is missing', () => {
+        expectValiError(() => parseValidateTokenRequest({}));
+    });
+});
+describe('parseValidateTokenResponse', () => {
+    it('accepts valid input', () => {
+        const r = { valid: true, userId: 'u1', expiresAt: '2026-12-31' };
+        expect(parseValidateTokenResponse(r)).toEqual(r);
+    });
+    it('accepts valid-only response payload', () => {
+        expect(parseValidateTokenResponse({ valid: true })).toEqual({ valid: true });
+    });
+    it('throws ValiError when valid is not boolean', () => {
+        expectValiError(() => parseValidateTokenResponse({ valid: 'yes', userId: 'u1', expiresAt: '2026-12-31' }));
+    });
+});
+describe('parseCliTokenMetadata', () => {
+    it('accepts valid input', () => {
+        const m = {
+            token: 't',
+            userId: 'u',
+            createdAt: '2026-01-01',
+            expiresAt: '2026-12-31',
+        };
+        expect(parseCliTokenMetadata(m)).toEqual(m);
+    });
+    it('throws ValiError when createdAt is missing', () => {
+        expectValiError(() => parseCliTokenMetadata({ token: 't', userId: 'u', expiresAt: '2026-12-31' }));
+    });
+});
+describe('parseGuideSnapshot', () => {
+    const snapshot = {
+        id: 'g1',
+        title: 'My Guide',
+        content: '# Rules',
+        enabled: true,
+        updatedAt: '2026-04-01',
+    };
+    it('accepts valid snapshot', () => {
+        expect(parseGuideSnapshot(snapshot)).toEqual(snapshot);
+    });
+    it('throws ValiError when enabled is not boolean', () => {
+        expectValiError(() => parseGuideSnapshot({ ...snapshot, enabled: 1 }));
+    });
+    it('accepts optional origin and contentHash for imported guides', () => {
+        const imported = {
+            ...snapshot,
+            origin: 'file:agents-dir:.agents/skill-foo/SKILL.md',
+            contentHash: 'a'.repeat(64),
+        };
+        expect(parseGuideSnapshot(imported)).toEqual(imported);
+    });
+    it('accepts null origin and contentHash for non-imported guides', () => {
+        expect(parseGuideSnapshot({ ...snapshot, origin: null, contentHash: null })).toEqual({
+            ...snapshot,
+            origin: null,
+            contentHash: null,
+        });
+    });
+    it('throws ValiError when contentHash is not a 64-char hex string', () => {
+        expectValiError(() => parseGuideSnapshot({ ...snapshot, contentHash: 'not-a-hash' }));
+    });
+});
+describe('parseGuideBundleResponse', () => {
+    it('accepts valid response', () => {
+        const r = { guides: [], pulledAt: '2026-04-01' };
+        expect(parseGuideBundleResponse(r)).toEqual(r);
+    });
+    it('throws ValiError when guides is not an array', () => {
+        expectValiError(() => parseGuideBundleResponse({ guides: null, pulledAt: 'x' }));
+    });
+});
+describe('parseRawGuideFilePayload', () => {
+    it('accepts a valid raw guide payload', () => {
+        const payload = {
+            path: '.agents/reviewer/SKILL.md',
+            format: 'agents-dir',
+            rawContent: '# Reviewer\n\n- Check tests.',
+            lastModified: 1_745_040_000_000,
+            content_hash: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        };
+        expect(parseRawGuideFilePayload(payload)).toEqual(payload);
+    });
+    it('rejects unsupported formats', () => {
+        expectValiError(() => parseRawGuideFilePayload({
+            path: 'README.md',
+            format: 'markdown',
+            rawContent: '# Nope',
+            lastModified: 1,
+            content_hash: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        }));
+    });
+    it('rejects invalid content hashes', () => {
+        expectValiError(() => parseRawGuideFilePayload({
+            path: 'AGENTS.md',
+            format: 'agents-md',
+            rawContent: '# Agents',
+            lastModified: 1,
+            content_hash: 'not-a-sha256',
+        }));
+    });
+    it('accepts rawContent up to the byte cap', () => {
+        const rawContent = 'a'.repeat(MAX_RAW_GUIDE_CONTENT_BYTES);
+        expect(() => parseRawGuideFilePayload({
+            path: 'AGENTS.md',
+            format: 'agents-md',
+            rawContent,
+            lastModified: 1,
+            content_hash: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        })).not.toThrow();
+    });
+    it('rejects rawContent over the byte cap', () => {
+        const rawContent = 'a'.repeat(MAX_RAW_GUIDE_CONTENT_BYTES + 1);
+        expectValiError(() => parseRawGuideFilePayload({
+            path: 'AGENTS.md',
+            format: 'agents-md',
+            rawContent,
+            lastModified: 1,
+            content_hash: '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef',
+        }));
+    });
+    describe('skill members', () => {
+        const HASH = '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
+        const member = (path) => ({
+            path,
+            rawContent: 'print("hi")',
+            lastModified: 1,
+            content_hash: HASH,
+        });
+        const skillPayload = (members) => ({
+            path: '.claude/skills/reviewer/SKILL.md',
+            format: 'skill-md',
+            rawContent: '# Reviewer',
+            lastModified: 1,
+            content_hash: HASH,
+            members,
+        });
+        it('accepts a skill-md payload with members, including an empty list', () => {
+            expect(() => parseRawGuideFilePayload(skillPayload([member('scripts/lint.py')]))).not.toThrow();
+            expect(() => parseRawGuideFilePayload(skillPayload([]))).not.toThrow();
+        });
+        it('rejects members on non-skill-md payloads', () => {
+            expectValiError(() => parseRawGuideFilePayload({
+                path: 'AGENTS.md',
+                format: 'agents-md',
+                rawContent: '# Agents',
+                lastModified: 1,
+                content_hash: HASH,
+                members: [],
+            }));
+        });
+        it('rejects unsafe member paths', () => {
+            for (const path of [
+                '../escape.md',
+                '/abs.md',
+                'a//b.md',
+                'a/../b.md',
+                './x.md',
+                'a\\b.md',
+                // Windows drive-letter absolute forms escape path.resolve(skillDir, …).
+                'C:/evil.md',
+                'c:relative-to-drive.md',
+                // Control characters must never reach a filesystem API on export.
+                'notes/\u0000evil.md',
+                'notes/line\nbreak.md',
+                // A member must not shadow the skill's own SKILL.md.
+                'SKILL.md',
+                'skill.md',
+            ]) {
+                expectValiError(() => parseRawGuideFilePayload(skillPayload([member(path)])));
+            }
+        });
+        it('accepts a nested SKILL.md member path (only the root one shadows)', () => {
+            expect(() => parseRawGuideFilePayload(skillPayload([member('references/SKILL.md')]))).not.toThrow();
+        });
+        it('rejects duplicate member paths, case-insensitively', () => {
+            expectValiError(() => parseRawGuideFilePayload(skillPayload([member('references/api.md'), member('references/api.md')])));
+            // Case-folding filesystems (macOS/Windows default) would collapse these
+            // into one file on export.
+            expectValiError(() => parseRawGuideFilePayload(skillPayload([member('references/api.md'), member('references/API.md')])));
+        });
+        it('rejects more members than the per-skill cap', () => {
+            const members = Array.from({ length: MAX_SKILL_MEMBER_FILES + 1 }, (_, i) => member(`references/${i}.md`));
+            expectValiError(() => parseRawGuideFilePayload(skillPayload(members)));
+        });
+        it('accepts skippedMemberPaths alongside members, with looser path rules', () => {
+            expect(() => parseRawGuideFilePayload({
+                ...skillPayload([member('scripts/lint.py')]),
+                // Skipped paths describe what is on disk — odd names must not fail
+                // the payload (they are only string-matched, never re-created).
+                skippedMemberPaths: ['assets/logo.png', 'weird name…\\here.bin'],
+            })).not.toThrow();
+        });
+        it('parses a member-files response and rejects unsafe paths in it', () => {
+            expect(() => parseGuideMemberFilesResponse({
+                memberFiles: [
+                    { path: 'scripts/lint.py', content: 'print("hi")', contentHash: HASH },
+                ],
+            })).not.toThrow();
+            expectValiError(() => parseGuideMemberFilesResponse({
+                memberFiles: [{ path: '../escape.md', content: 'x', contentHash: HASH }],
+            }));
+            // Case-collisions resolve to one file on macOS/Windows — the second
+            // would silently clobber the first without an OVERWRITE prompt.
+            expectValiError(() => parseGuideMemberFilesResponse({
+                memberFiles: [
+                    { path: 'notes.md', content: 'a', contentHash: HASH },
+                    { path: 'Notes.md', content: 'b', contentHash: HASH },
+                ],
+            }));
+        });
+        it('rejects skippedMemberPaths without members', () => {
+            expectValiError(() => parseRawGuideFilePayload({
+                ...skillPayload(undefined),
+                members: undefined,
+                skippedMemberPaths: ['assets/logo.png'],
+            }));
+        });
+    });
+});
+describe('parseRulesImportRequest', () => {
+    it('accepts an empty rules array', () => {
+        expect(parseRulesImportRequest({ rules: [] })).toEqual({ rules: [] });
+    });
+    it('accepts a rules array up to the batch cap', () => {
+        const rules = Array.from({ length: MAX_RULES_IMPORT_BATCH }, () => ({}));
+        expect(() => parseRulesImportRequest({ rules })).not.toThrow();
+    });
+    it('rejects a rules array over the batch cap', () => {
+        const rules = Array.from({ length: MAX_RULES_IMPORT_BATCH + 1 }, () => ({}));
+        expectValiError(() => parseRulesImportRequest({ rules }));
+    });
+    it('rejects a body without a rules array', () => {
+        expectValiError(() => parseRulesImportRequest({}));
+        expectValiError(() => parseRulesImportRequest({ rules: 'oops' }));
+    });
+});
+describe('parseRuleDeletionsRequest', () => {
+    const deletion = { path: 'AGENTS.md', format: 'agents-md' };
+    it('accepts a deletions array up to the batch cap', () => {
+        const deletions = Array.from({ length: MAX_RULE_DELETIONS_BATCH }, () => deletion);
+        expect(() => parseRuleDeletionsRequest({ deletions })).not.toThrow();
+    });
+    it('rejects a deletions array over the batch cap', () => {
+        const deletions = Array.from({ length: MAX_RULE_DELETIONS_BATCH + 1 }, () => deletion);
+        expectValiError(() => parseRuleDeletionsRequest({ deletions }));
+    });
+});
+describe('parseNormalizedGuide', () => {
+    const valid = {
+        rules: [
+            { text: 'Use single quotes for strings.', section: 'Style' },
+            { text: 'Top-level instruction.', section: null },
+        ],
+        summary: 'Repository conventions for a TypeScript dashboard.',
+    };
+    it('accepts a valid payload with mixed-section rules', () => {
+        expect(parseNormalizedGuide(valid)).toEqual(valid);
+    });
+    it('accepts an empty rules array', () => {
+        const payload = { rules: [], summary: 'No actionable rules detected.' };
+        expect(parseNormalizedGuide(payload)).toEqual(payload);
+    });
+    it('rejects empty rule text', () => {
+        expectValiError(() => parseNormalizedGuide({
+            rules: [{ text: '', section: null }],
+            summary: 'x',
+        }));
+    });
+    it('rejects rules with missing section field', () => {
+        expectValiError(() => parseNormalizedGuide({
+            rules: [{ text: 'a rule' }],
+            summary: 'x',
+        }));
+    });
+    it('rejects payloads missing summary', () => {
+        expectValiError(() => parseNormalizedGuide({
+            rules: [{ text: 'a rule', section: null }],
+        }));
+    });
+    it('rejects non-array rules', () => {
+        expectValiError(() => parseNormalizedGuide({
+            rules: 'not an array',
+            summary: 'x',
+        }));
+    });
+});
+describe('parseDashboardSyncRequest', () => {
+    it('accepts a valid dashboard sync payload', () => {
+        const payload = {
+            actions: [
+                {
+                    id: 'action-1',
+                    actionType: 'file_edit',
+                    summary: 'Edited src/index.ts',
+                    verdict: 'aligned',
+                    gradingTier: 'pattern_match',
+                    filePaths: ['/src/index.ts'],
+                    metadata: { prompt: 'update component' },
+                },
+            ],
+            guideSuggestions: [
+                {
+                    id: 'guide-1',
+                    content: 'Avoid adding unit tests unless requested.',
+                    reasoning: 'Repeated correction across sessions.',
+                    triggerType: 'conversational_feedback',
+                    sourceActionIds: [
+                        {
+                            sessionId: 'session-1',
+                            timestamp: '2026-04-19T10:00:00Z',
+                            summary: 'Asked the agent not to add tests.',
+                        },
+                    ],
+                    status: 'pending',
+                },
+            ],
+            feedbackCandidates: [
+                {
+                    id: 'candidate-1',
+                    signal: 'Repeated workflow: bun test → bun run lint.',
+                    signalType: 'skill_suggestion',
+                    confidence: 0.78,
+                    occurrences: 2,
+                    status: 'inferred',
+                },
+            ],
+        };
+        expect(parseDashboardSyncRequest(payload)).toEqual(payload);
+    });
+    it('accepts run usage entries', () => {
+        const payload = {
+            actions: [],
+            guideSuggestions: [],
+            feedbackCandidates: [],
+            runUsage: [
+                {
+                    runId: 'run-1',
+                    sessionId: 'session-1',
+                    usage: [
+                        {
+                            model: 'claude-sonnet-5',
+                            inputTokens: 100,
+                            outputTokens: 50,
+                            cacheReadTokens: 200,
+                            cacheWriteTokens: 10,
+                        },
+                    ],
+                },
+            ],
+        };
+        expect(parseDashboardSyncRequest(payload)).toEqual(payload);
+    });
+    it('throws ValiError when a run usage entry has negative tokens', () => {
+        expectValiError(() => parseDashboardSyncRequest({
+            actions: [],
+            guideSuggestions: [],
+            feedbackCandidates: [],
+            runUsage: [
+                {
+                    sessionId: 'session-1',
+                    usage: [{ model: 'claude-sonnet-5', inputTokens: -1, outputTokens: 50 }],
+                },
+            ],
+        }));
+    });
+    it('throws ValiError when a guide suggestion is malformed', () => {
+        expectValiError(() => parseDashboardSyncRequest({
+            actions: [],
+            guideSuggestions: [
+                {
+                    content: 'Always use strict mode',
+                    reasoning: 'Repeated gap',
+                    triggerType: 'not-valid',
+                },
+            ],
+            feedbackCandidates: [],
+        }));
+    });
+    it('throws ValiError when a feedback candidate is malformed', () => {
+        expectValiError(() => parseDashboardSyncRequest({
+            actions: [],
+            guideSuggestions: [],
+            feedbackCandidates: [
+                {
+                    signal: 'Repeated workflow',
+                    signalType: 'skill_suggestion',
+                    confidence: 1.5,
+                },
+            ],
+        }));
+    });
+    it('accepts action metadata up to the size cap', () => {
+        // -2 to leave room for the wrapping `{"x":"..."}` quotes/braces.
+        const value = 'a'.repeat(MAX_ACTION_METADATA_BYTES - '{"x":""}'.length);
+        const payload = {
+            actions: [
+                {
+                    actionType: 'file_edit',
+                    summary: 'Edited src/index.ts',
+                    metadata: { x: value },
+                },
+            ],
+        };
+        expect(() => parseDashboardSyncRequest(payload)).not.toThrow();
+    });
+    it('throws ValiError when action metadata exceeds the size cap', () => {
+        const value = 'a'.repeat(MAX_ACTION_METADATA_BYTES);
+        expectValiError(() => parseDashboardSyncRequest({
+            actions: [
+                {
+                    actionType: 'file_edit',
+                    summary: 'Edited src/index.ts',
+                    metadata: { x: value },
+                },
+            ],
+        }));
+    });
+    it('accepts actions up to the batch cap', () => {
+        const actions = Array.from({ length: MAX_SYNC_ACTIONS_BATCH }, (_, i) => ({
+            actionType: 'file_edit',
+            summary: `action-${i}`,
+        }));
+        expect(() => parseDashboardSyncRequest({ actions })).not.toThrow();
+    });
+    it('throws ValiError when actions exceed the batch cap', () => {
+        const actions = Array.from({ length: MAX_SYNC_ACTIONS_BATCH + 1 }, (_, i) => ({
+            actionType: 'file_edit',
+            summary: `action-${i}`,
+        }));
+        expectValiError(() => parseDashboardSyncRequest({ actions }));
+    });
+    it('throws ValiError when guideSuggestions exceed the batch cap', () => {
+        const guideSuggestions = Array.from({ length: MAX_SYNC_AUX_BATCH + 1 }, () => ({
+            content: 'Always use strict mode.',
+            triggerType: 'uncovered',
+        }));
+        expectValiError(() => parseDashboardSyncRequest({ guideSuggestions }));
+    });
+    it('throws ValiError when feedbackCandidates exceed the batch cap', () => {
+        const feedbackCandidates = Array.from({ length: MAX_SYNC_AUX_BATCH + 1 }, () => ({
+            signal: 'Repeated workflow.',
+            signalType: 'correction',
+        }));
+        expectValiError(() => parseDashboardSyncRequest({ feedbackCandidates }));
+    });
+    it('throws ValiError when runUsage exceeds the batch cap', () => {
+        const runUsage = Array.from({ length: MAX_SYNC_AUX_BATCH + 1 }, (_, i) => ({
+            sessionId: `session-${i}`,
+            usage: [],
+        }));
+        expectValiError(() => parseDashboardSyncRequest({ runUsage }));
+    });
+});
+describe('conversational feedback schemas', () => {
+    const citation = {
+        sessionId: 'session-1',
+        timestamp: '2026-04-19T10:00:00Z',
+        summary: 'Asked the agent not to add unit tests.',
+    };
+    it('accepts a valid proposal citation', () => {
+        expect(parseProposalCitation(citation)).toEqual(citation);
+    });
+    it('accepts a valid extracted guide suggestion', () => {
+        const suggestion = {
+            id: 'guide-1',
+            content: 'Avoid adding unit tests unless the user asks for them.',
+            reasoning: 'Observed the same correction in three Claude Code sessions.',
+            triggerType: 'conversational_feedback',
+            confidence: 0.88,
+            occurrences: 3,
+            citations: [citation],
+            source: 'claude_code',
+        };
+        expect(parseExtractedGuideSuggestion(suggestion)).toEqual(suggestion);
+    });
+    it('accepts a valid extracted skill suggestion', () => {
+        const suggestion = {
+            id: 'skill-1',
+            signal: 'Repeated workflow: bun test → bun run lint.',
+            confidence: 0.76,
+            occurrences: 2,
+            citations: [citation],
+            source: 'claude_code',
+        };
+        expect(parseExtractedSkillSuggestion(suggestion)).toEqual(suggestion);
+    });
+    it('accepts a valid extracted feedback batch', () => {
+        const batch = {
+            guideSuggestions: [
+                {
+                    id: 'guide-1',
+                    content: 'Prefer var over explicit types.',
+                    reasoning: 'Observed the same correction in two sessions.',
+                    triggerType: 'conversational_feedback',
+                    confidence: 0.72,
+                    occurrences: 2,
+                    citations: [citation],
+                    source: 'claude_code',
+                },
+            ],
+            skillSuggestions: [
+                {
+                    id: 'skill-1',
+                    signal: 'Repeated workflow: bun test → bun run lint.',
+                    confidence: 0.76,
+                    occurrences: 2,
+                    citations: [citation],
+                    source: 'claude_code',
+                },
+            ],
+        };
+        expect(parseExtractedFeedbackBatch(batch)).toEqual(batch);
+    });
+    it('rejects guide suggestions with unsupported trigger types', () => {
+        expectValiError(() => parseExtractedGuideSuggestion({
+            id: 'guide-1',
+            content: 'x',
+            reasoning: 'y',
+            triggerType: 'uncovered',
+            confidence: 0.9,
+            occurrences: 2,
+            citations: [citation],
+            source: 'claude_code',
+        }));
+    });
+});
+describe('parseProjectionRequest', () => {
+    it('accepts valid input', () => {
+        const r = { agents: [], outputDir: './out' };
+        expect(parseProjectionRequest(r)).toEqual(r);
+    });
+    it('throws ValiError when outputDir is missing', () => {
+        expectValiError(() => parseProjectionRequest({ agents: [] }));
+    });
+});
+describe('parseProjectionResult', () => {
+    it('accepts valid input', () => {
+        const r = { agentsMd: '# Agents', agentsDir: {} };
+        expect(parseProjectionResult(r)).toEqual(r);
+    });
+    it('throws ValiError when agentsMd is missing', () => {
+        expectValiError(() => parseProjectionResult({ agentsDir: {} }));
+    });
+});
+describe('parseActionEntry', () => {
+    it('accepts valid entry with all fields', () => {
+        const entry = {
+            timestamp: '2026-04-19T10:00:00Z',
+            sessionId: 'abc123',
+            toolName: 'Edit',
+            filePath: '/src/foo.ts',
+            command: undefined,
+        };
+        expect(parseActionEntry(entry)).toMatchObject({
+            timestamp: entry.timestamp,
+            sessionId: entry.sessionId,
+            toolName: entry.toolName,
+            filePath: entry.filePath,
+        });
+    });
+    it('accepts entry without optional fields', () => {
+        const entry = {
+            timestamp: '2026-04-19T10:00:00Z',
+            sessionId: 'abc',
+            toolName: 'Read',
+        };
+        expect(parseActionEntry(entry)).toMatchObject(entry);
+    });
+    it('throws ValiError when toolName is missing', () => {
+        expectValiError(() => parseActionEntry({ timestamp: 't', sessionId: 's' }));
+    });
+    it('throws ValiError when sessionId is missing', () => {
+        expectValiError(() => parseActionEntry({ timestamp: 't', toolName: 'Edit' }));
+    });
+});
+describe('parseRuleVerdict', () => {
+    it('accepts aligned verdict', () => {
+        const v = {
+            rule: 'Use single quotes',
+            verdict: 'aligned',
+            reasoning: 'All edits used single quotes',
+        };
+        expect(parseRuleVerdict(v)).toEqual(v);
+    });
+    it('accepts misaligned verdict', () => {
+        const v = {
+            rule: 'Write tests',
+            verdict: 'misaligned',
+            reasoning: 'No test file created',
+        };
+        expect(parseRuleVerdict(v)).toEqual(v);
+    });
+    it('accepts not_applicable verdict', () => {
+        const v = {
+            rule: 'Use Tamagui',
+            verdict: 'not_applicable',
+            reasoning: 'No UI changes',
+        };
+        expect(parseRuleVerdict(v)).toEqual(v);
+    });
+    it('throws ValiError on invalid verdict', () => {
+        expectValiError(() => parseRuleVerdict({ rule: 'x', verdict: 'unknown', reasoning: 'y' }));
+    });
+    it('throws ValiError when reasoning is missing', () => {
+        expectValiError(() => parseRuleVerdict({ rule: 'x', verdict: 'aligned' }));
+    });
+});
+describe('parseRunEvalResult', () => {
+    const valid = {
+        verdicts: [{ rule: 'Use single quotes', verdict: 'aligned', reasoning: 'ok' }],
+        summary: '1/1 rules followed',
+        score: 1.0,
+    };
+    it('accepts valid result', () => {
+        expect(parseRunEvalResult(valid)).toEqual(valid);
+    });
+    it('accepts score of 0.0', () => {
+        expect(parseRunEvalResult({ ...valid, score: 0 })).toMatchObject({ score: 0 });
+    });
+    it('throws ValiError when score exceeds 1', () => {
+        expectValiError(() => parseRunEvalResult({ ...valid, score: 1.5 }));
+    });
+    it('throws ValiError when score is negative', () => {
+        expectValiError(() => parseRunEvalResult({ ...valid, score: -0.1 }));
+    });
+    it('throws ValiError when verdicts is not an array', () => {
+        expectValiError(() => parseRunEvalResult({ ...valid, verdicts: null }));
+    });
+});
+describe('parseBundle', () => {
+    const valid = {
+        id: 'bundle-1',
+        slug: 'travel-log',
+        name: 'Travel Log',
+        kind: 'user',
+        createdAt: '2026-07-06T00:00:00.000Z',
+    };
+    it('accepts a valid bundle', () => {
+        expect(parseBundle(valid)).toEqual(valid);
+    });
+    it('accepts each bundle kind', () => {
+        for (const kind of ['user', 'inbox', 'system']) {
+            expect(parseBundle({ ...valid, kind })).toMatchObject({ kind });
+        }
+    });
+    it('throws ValiError on an unknown kind', () => {
+        expectValiError(() => parseBundle({ ...valid, kind: 'archive' }));
+    });
+    it('throws ValiError on an uppercase slug', () => {
+        expectValiError(() => parseBundle({ ...valid, slug: 'Travel-Log' }));
+    });
+    it('throws ValiError on a slug with spaces', () => {
+        expectValiError(() => parseBundle({ ...valid, slug: 'travel log' }));
+    });
+    it('throws ValiError on a slug starting with a hyphen', () => {
+        expectValiError(() => parseBundle({ ...valid, slug: '-notes' }));
+    });
+});
+describe('parseBundleListResponse', () => {
+    it('accepts an empty list', () => {
+        expect(parseBundleListResponse({ bundles: [] })).toEqual({ bundles: [] });
+    });
+    it('throws ValiError when bundles is missing', () => {
+        expectValiError(() => parseBundleListResponse({}));
+    });
+});
+describe('parseCreateBundleRequest', () => {
+    it('accepts slug + name without kind', () => {
+        expect(parseCreateBundleRequest({ slug: 'notes', name: 'Notes' })).toEqual({
+            slug: 'notes',
+            name: 'Notes',
+        });
+    });
+    it('accepts an optional kind', () => {
+        expect(parseCreateBundleRequest({ slug: 'notes', name: 'Notes', kind: 'user' })).toMatchObject({ kind: 'user' });
+    });
+    it('throws ValiError when name is empty', () => {
+        expectValiError(() => parseCreateBundleRequest({ slug: 'notes', name: '' }));
+    });
+    it('throws ValiError when slug is invalid', () => {
+        expectValiError(() => parseCreateBundleRequest({ slug: 'My Notes', name: 'Notes' }));
+    });
+});
+describe('parseCreateBundleResponse', () => {
+    it('accepts a wrapped bundle', () => {
+        const bundle = {
+            id: 'bundle-1',
+            slug: 'notes',
+            name: 'Notes',
+            kind: 'user',
+            createdAt: '2026-07-06T00:00:00.000Z',
+        };
+        expect(parseCreateBundleResponse({ bundle })).toEqual({ bundle });
+    });
+    it('throws ValiError when bundle is missing', () => {
+        expectValiError(() => parseCreateBundleResponse({}));
+    });
+});
+describe('parseContextItem', () => {
+    const valid = {
+        id: 'file-1',
+        type: 'document',
+        name: 'Trip notes',
+        contentType: 'document',
+        content: 'Went to Lisbon.',
+        origin: null,
+        updatedAt: '2026-07-06T00:00:00.000Z',
+    };
+    it('accepts a valid item', () => {
+        expect(parseContextItem(valid)).toEqual(valid);
+    });
+    it('accepts each item type', () => {
+        for (const type of ['guide', 'document', 'reference', 'asset']) {
+            expect(parseContextItem({ ...valid, type })).toMatchObject({ type });
+        }
+    });
+    it('accepts null content (assets store an object key elsewhere)', () => {
+        expect(parseContextItem({ ...valid, type: 'asset', content: null })).toMatchObject({
+            content: null,
+        });
+    });
+    it('throws ValiError on an unknown type', () => {
+        expectValiError(() => parseContextItem({ ...valid, type: 'note' }));
+    });
+});
+describe('parseContextItemsResponse', () => {
+    it('accepts an empty list', () => {
+        expect(parseContextItemsResponse({ items: [] })).toEqual({ items: [] });
+    });
+    it('throws ValiError when items is missing', () => {
+        expectValiError(() => parseContextItemsResponse({}));
+    });
+});
+describe('parsePushContextRequest', () => {
+    const valid = { name: 'Notes', contentType: 'document', content: 'body' };
+    it('accepts a minimal create payload', () => {
+        expect(parsePushContextRequest(valid)).toMatchObject(valid);
+    });
+    it('accepts an optional itemId + origin', () => {
+        expect(parsePushContextRequest({ ...valid, itemId: 'file-1', origin: 'cli' })).toMatchObject({ itemId: 'file-1', origin: 'cli' });
+    });
+    it('throws ValiError on a non-writable contentType', () => {
+        expectValiError(() => parsePushContextRequest({ ...valid, contentType: 'guide' }));
+    });
+    it('throws ValiError when name is empty', () => {
+        expectValiError(() => parsePushContextRequest({ ...valid, name: '' }));
+    });
+    it('throws ValiError when content exceeds the byte cap', () => {
+        const content = 'a'.repeat(MAX_CONTEXT_CONTENT_BYTES + 1);
+        expectValiError(() => parsePushContextRequest({ ...valid, content }));
+    });
+    it('accepts sourceItemIds citing the transform sources', () => {
+        expect(parsePushContextRequest({ ...valid, sourceItemIds: ['item-1', 'item-2'] })).toMatchObject({ sourceItemIds: ['item-1', 'item-2'] });
+    });
+    it('throws ValiError on an empty sourceItemIds array', () => {
+        expectValiError(() => parsePushContextRequest({ ...valid, sourceItemIds: [] }));
+    });
+    it('throws ValiError when sourceItemIds exceeds the batch cap', () => {
+        const ids = Array.from({ length: MAX_TRANSFORM_SOURCE_IDS + 1 }, (_, i) => `id-${i}`);
+        expectValiError(() => parsePushContextRequest({ ...valid, sourceItemIds: ids }));
+    });
+});
+describe('parsePushContextResponse', () => {
+    const item = {
+        id: 'file-1',
+        type: 'document',
+        name: 'Notes',
+        contentType: 'document',
+        content: 'body',
+        updatedAt: '2026-07-10T00:00:00.000Z',
+    };
+    it('accepts a response without a transform grade', () => {
+        expect(parsePushContextResponse({ item, created: true })).toMatchObject({
+            created: true,
+        });
+    });
+    it('accepts a response carrying a transform grade', () => {
+        const transform = {
+            actionId: 'action-1',
+            verdict: 'aligned',
+            gradingTier: 'llm',
+            reasoning: 'All facts preserved.',
+        };
+        expect(parsePushContextResponse({ item, created: true, transform })).toMatchObject({
+            transform,
+        });
+    });
+    it('tolerates a future gradingTier value (open string, not a picklist)', () => {
+        expect(parsePushContextResponse({
+            item,
+            created: true,
+            transform: {
+                actionId: 'action-1',
+                verdict: 'aligned',
+                gradingTier: 'cached',
+                reasoning: null,
+            },
+        }).transform?.gradingTier).toBe('cached');
+    });
+    it('throws ValiError on an unknown transform verdict', () => {
+        expectValiError(() => parsePushContextResponse({
+            item,
+            created: true,
+            transform: {
+                actionId: 'action-1',
+                verdict: 'passed',
+                gradingTier: 'llm',
+                reasoning: null,
+            },
+        }));
+    });
+});
+describe('parseUpdateContextItemRequest', () => {
+    it('accepts a partial update (content only)', () => {
+        expect(parseUpdateContextItemRequest({ itemId: 'file-1', content: 'new' })).toMatchObject({
+            itemId: 'file-1',
+            content: 'new',
+        });
+    });
+    it('throws ValiError when itemId is empty', () => {
+        expectValiError(() => parseUpdateContextItemRequest({ itemId: '', content: 'new' }));
+    });
+});
+describe('parseInboxCaptureRequest', () => {
+    it('accepts a text capture', () => {
+        expect(parseInboxCaptureRequest({ contentType: 'document', content: 'quick note' })).toMatchObject({ contentType: 'document' });
+    });
+    it('accepts an optional name + source', () => {
+        expect(parseInboxCaptureRequest({
+            contentType: 'document',
+            content: 'x',
+            name: 'Idea',
+            source: 'app',
+        })).toMatchObject({ name: 'Idea', source: 'app' });
+    });
+    it('throws ValiError on a reference contentType (inbox is document | asset)', () => {
+        expectValiError(() => parseInboxCaptureRequest({ contentType: 'reference', content: 'x' }));
+    });
+});
+describe('parseInboxListResponse', () => {
+    it('accepts an empty list', () => {
+        expect(parseInboxListResponse({ items: [] })).toEqual({ items: [] });
+    });
+    it('accepts an item carrying capture provenance', () => {
+        const item = {
+            id: 'file-1',
+            type: 'document',
+            name: 'Note',
+            contentType: 'document',
+            content: 'x',
+            source: 'app',
+            capturedAt: '2026-07-06T00:00:00.000Z',
+            updatedAt: '2026-07-06T00:00:00.000Z',
+        };
+        expect(parseInboxListResponse({ items: [item] })).toEqual({ items: [item] });
+    });
+});
+describe('parseInboxArchiveRequest', () => {
+    it('accepts a non-empty id list', () => {
+        expect(parseInboxArchiveRequest({ ids: ['file-1', 'file-2'] })).toEqual({
+            ids: ['file-1', 'file-2'],
+        });
+    });
+    it('throws ValiError on an empty id list', () => {
+        expectValiError(() => parseInboxArchiveRequest({ ids: [] }));
+    });
+    it('accepts an id list up to the batch cap', () => {
+        const ids = Array.from({ length: MAX_INBOX_ARCHIVE_BATCH }, (_, i) => `id-${i}`);
+        expect(() => parseInboxArchiveRequest({ ids })).not.toThrow();
+    });
+    it('throws ValiError on an id list over the batch cap', () => {
+        const ids = Array.from({ length: MAX_INBOX_ARCHIVE_BATCH + 1 }, (_, i) => `id-${i}`);
+        expectValiError(() => parseInboxArchiveRequest({ ids }));
+    });
+});
+//# sourceMappingURL=schemas.test.js.map