aaronrene / knowtation public

model-runtime-lane-e2e.test.mjs file-level

at sha256:0 · View file ↗ · Intel ↗

History
1 files
1 commits
0 hotspots
0 🧊 dead
0 💥 blast risk
sha256:9 feat(calendar): hosted bridge/gateway route parity and timeline noteRec… · aaronrene · Jun 19, 2026
1 /**
2 * Tier 3 — END-TO-END: model-runtime-lane full scenario paths
3 *
4 * Simulates complete real-world scenarios that span the full module contract —
5 * from raw capability/preference inputs through lane selection → policy gate →
6 * metering classification to a terminal routing decision. These scenarios
7 * correspond to the product's stated user journeys from the architecture brief.
8 *
9 * Reference: docs/COMPANION-APP-MODEL-ROUTING-AND-ENRICHMENT-ARCHITECTURE.md §4
10 * docs/COMPANION-APP-PHASE-1-ADAPTER-SEAM.md §1–3
11 */
12 import { describe, it } from 'node:test';
13 import assert from 'node:assert/strict';
14 import {
15 selectLane,
16 isManagedLane,
17 enforceConsentPolicy,
18 } from '../lib/model-runtime-lane.mjs';
19
20 /**
21 * Represents the complete routing result a caller receives.
22 * @param {object} caps
23 * @param {object} prefs
24 * @param {{ containsPrivateData: boolean, consentId?: string }} req
25 */
26 function route(caps, prefs, req) {
27 const lane = selectLane(caps, prefs);
28 return {
29 lane,
30 metered: isManagedLane(lane),
31 decision: enforceConsentPolicy({
32 lane,
33 containsPrivateData: req.containsPrivateData,
34 consentId: req.consentId,
35 isDelegate: prefs.isDelegate ?? false,
36 delegatedManagedAllowed: prefs.delegatedManagedAllowed ?? false,
37 }),
38 };
39 }
40
41 describe('E2E — Scenario 1: Power user, laptop with companion, private notes', () => {
42 it('routes to companion (local), not metered, allowed without consent', () => {
43 const result = route(
44 { companionAvailable: true, managedKeyAvailable: true },
45 { keepOnDevice: true },
46 { containsPrivateData: true },
47 );
48 assert.equal(result.lane, 'local');
49 assert.equal(result.metered, false);
50 assert.equal(result.decision, 'allow');
51 });
52 });
53
54 describe('E2E — Scenario 2: Student on school Chromebook (no companion, no WebGPU)', () => {
55 it('managed lane, non-private data (schoolwork), no consent needed', () => {
56 const result = route(
57 { managedKeyAvailable: true },
58 {},
59 { containsPrivateData: false },
60 );
61 assert.equal(result.lane, 'direct_provider');
62 assert.equal(result.metered, true);
63 assert.equal(result.decision, 'allow');
64 });
65
66 it('managed lane, private personal note, consent prompt required', () => {
67 const result = route(
68 { managedKeyAvailable: true },
69 {},
70 { containsPrivateData: true },
71 );
72 assert.equal(result.lane, 'direct_provider');
73 assert.equal(result.decision, 'cloud_consent_required');
74 });
75
76 it('managed lane, private note, student provides consent: allowed', () => {
77 const result = route(
78 { managedKeyAvailable: true },
79 {},
80 { containsPrivateData: true, consentId: 'student-consent-001' },
81 );
82 assert.equal(result.lane, 'direct_provider');
83 assert.equal(result.decision, 'allow');
84 });
85 });
86
87 describe('E2E — Scenario 3: Research org (privacy mode, own server)', () => {
88 it('self-hosted lane: not metered, private data freely allowed', () => {
89 const result = route(
90 { selfHostedAvailable: true, managedKeyAvailable: true },
91 { orgPrivacyMode: true },
92 { containsPrivateData: true },
93 );
94 assert.equal(result.lane, 'self_hosted');
95 assert.equal(result.metered, false);
96 assert.equal(result.decision, 'allow');
97 });
98
99 it('org privacy mode: managed never selected even when all other capabilities absent', () => {
100 const result = route(
101 { managedKeyAvailable: true },
102 { orgPrivacyMode: true },
103 { containsPrivateData: false },
104 );
105 assert.notEqual(result.lane, 'direct_provider');
106 assert.equal(result.lane, 'disabled');
107 });
108 });
109
110 describe('E2E — Scenario 4: Developer with OpenRouter BYO key', () => {
111 it('openrouter lane: not metered, private data allowed (user owns contract)', () => {
112 const result = route(
113 { openrouterKeyAvailable: true, managedKeyAvailable: true },
114 {},
115 { containsPrivateData: true },
116 );
117 assert.equal(result.lane, 'openrouter');
118 assert.equal(result.metered, false);
119 assert.equal(result.decision, 'allow');
120 });
121 });
122
123 describe('E2E — Scenario 5: Teacher (member) enriching student workspace notes (delegation)', () => {
124 it('owner has not opted in: lane_policy_denied — teacher cannot spend owner packs', () => {
125 const result = route(
126 { managedKeyAvailable: true },
127 { isDelegate: true, delegatedManagedAllowed: false },
128 { containsPrivateData: false, consentId: 'teacher-consent' },
129 );
130 assert.equal(result.lane, 'direct_provider');
131 assert.equal(result.decision, 'lane_policy_denied');
132 });
133
134 it('owner opted in, teacher acts on non-private note: allowed and metered to owner', () => {
135 const result = route(
136 { managedKeyAvailable: true },
137 { isDelegate: true, delegatedManagedAllowed: true },
138 { containsPrivateData: false },
139 );
140 assert.equal(result.lane, 'direct_provider');
141 assert.equal(result.metered, true); // billed to owner workspace
142 assert.equal(result.decision, 'allow');
143 });
144
145 it('teacher companion read-only completion (no write-back) is allowed locally', () => {
146 // Not an enrichment write to the owner's partition — the teacher already has read scope.
147 const result = route(
148 { companionAvailable: true },
149 { isDelegate: true, delegatedManagedAllowed: false },
150 { containsPrivateData: true },
151 );
152 assert.equal(result.lane, 'local');
153 assert.equal(result.metered, false);
154 assert.equal(result.decision, 'allow');
155 });
156
157 it('teacher companion ENRICHING owner notes (write-back) is denied until owner opts in (D1.3(2))', () => {
158 const lane = selectLane({ companionAvailable: true }, { isDelegate: true });
159 const decision = enforceConsentPolicy({
160 lane,
161 containsPrivateData: true,
162 consentId: undefined,
163 isDelegate: true,
164 delegatedManagedAllowed: false,
165 enrichesDelegatedPartition: true,
166 delegatedEnrichmentAllowed: false,
167 });
168 assert.equal(lane, 'local');
169 assert.equal(decision, 'lane_policy_denied');
170 });
171
172 it('teacher companion enriching owner notes is allowed once owner enables delegated enrichment', () => {
173 const lane = selectLane({ companionAvailable: true }, { isDelegate: true });
174 const decision = enforceConsentPolicy({
175 lane,
176 containsPrivateData: true,
177 consentId: undefined,
178 isDelegate: true,
179 delegatedManagedAllowed: false,
180 enrichesDelegatedPartition: true,
181 delegatedEnrichmentAllowed: true,
182 });
183 assert.equal(decision, 'allow');
184 });
185 });
186
187 describe('E2E — Scenario 6: User on phone (no companion, no WebGPU), all paths', () => {
188 it('embeddings-only fallback when nothing is available', () => {
189 const result = route({}, {}, { containsPrivateData: false });
190 assert.equal(result.lane, 'disabled');
191 assert.equal(result.metered, false);
192 assert.equal(result.decision, 'allow');
193 });
194 });