@pyric/cli 0.1.0-alpha.19 → 0.1.0-alpha.21

package/src/serve/entries/active-auth.ts

@@ -0,0 +1,100 @@
+import * as ipAuth from 'pyric/auth';
+import * as wcRaw from '../worker/client.js';
+import { acceptProviderCredential, restorePortSession } from '../worker/client.js';
+import {
+  projectRuntimeIdentity,
+  type RuntimeIdentity,
+} from '../runtime/identity.js';
+import { createActiveAuthRegistry } from './active-auth-registry.js';
+import { useWorker } from './worker-runtime.js';
+
+const wc = wcRaw as unknown as typeof ipAuth;
+const selectedAuth = useWorker ? wc : ipAuth;
+type ActiveAuth = { currentUser: RuntimeIdentity | null };
+const observeActiveAuth = selectedAuth.onAuthStateChanged as unknown as (
+  auth: ActiveAuth,
+  listener: (user: RuntimeIdentity | null) => void,
+) => () => void;
+const activeAuthRegistry = createActiveAuthRegistry<ActiveAuth>(observeActiveAuth);
+
+export function registerActiveAuth(auth: ActiveAuth): () => void {
+  return activeAuthRegistry.register(auth);
+}
+
+export function subscribeToActiveAuth(
+  listener: (user: RuntimeIdentity | null) => void,
+): () => void {
+  return activeAuthRegistry.subscribe(listener);
+}
+
+export function getActiveAuthUser(): RuntimeIdentity | null {
+  for (const auth of activeAuthRegistry.auths()) {
+    if (auth.currentUser) {
+      return projectRuntimeIdentity(auth.currentUser);
+    }
+  }
+  return null;
+}
+
+export async function switchAllAuthUsers(uid: string): Promise<void> {
+  const promises: Promise<unknown>[] = [];
+  for (const auth of activeAuthRegistry.auths()) {
+    if (useWorker) {
+      promises.push(restorePortSession(auth as never, uid));
+    } else {
+      try {
+        ipAuth.sandbox.restoreSession(auth as never, uid);
+      } catch {
+        // A stale handle or unavailable identity must not block other handles.
+      }
+    }
+  }
+  await Promise.all(promises);
+}
+
+export async function signOutAllAuths(): Promise<void> {
+  const promises: Promise<unknown>[] = [];
+  for (const auth of activeAuthRegistry.auths()) {
+    if (useWorker) {
+      promises.push(wc.signOut(auth as never));
+    } else {
+      promises.push(ipAuth.signOut(auth as never));
+    }
+  }
+  await Promise.all(promises);
+}
+
+export async function commitCredentialToAllAuths(identity: {
+  uid: string;
+  email?: string | null;
+  displayName?: string | null;
+  customClaims?: Record<string, unknown>;
+  providerId?: string;
+}): Promise<void> {
+  const promises: Promise<unknown>[] = [];
+  for (const auth of activeAuthRegistry.auths()) {
+    if (useWorker) {
+      promises.push(acceptProviderCredential(auth as never, {
+        uid: identity.uid,
+        email: identity.email ?? null,
+        displayName: identity.displayName ?? null,
+        customClaims: identity.customClaims ?? {},
+        providerId: identity.providerId ?? 'password',
+      }));
+    } else {
+      try {
+        ipAuth.sandbox.seedUsers(auth as never, [{
+          uid: identity.uid,
+          email: identity.email ?? '',
+          password: 'synthetic-password',
+          displayName: identity.displayName ?? undefined,
+          customClaims: identity.customClaims ?? {},
+          providerId: identity.providerId ?? 'password',
+        }]);
+      } catch {
+        // A stale handle or duplicate seed must not block other handles.
+      }
+    }
+  }
+  await Promise.all(promises);
+}

package/src/serve/entries/ai.ts

@@ -105,6 +105,16 @@ function toEngineWire(engine: EngineOption | undefined): AiEngineConfigWire | un
       ...(openai.modelMap !== undefined ? { modelMap: openai.modelMap } : {}),
     };
   }
+  if (config.kind === 'gemini') {
+    const gemini = config as Extract<EngineOption, { kind: 'gemini' }>;
+    const hasBaseUrl = gemini.baseUrl !== undefined;
+    const hasApiKey = gemini.apiKey !== undefined;
+    return {
+      kind: 'gemini',
+      ...(hasBaseUrl ? { baseUrl: gemini.baseUrl } : {}),
+      ...(hasApiKey ? { apiKey: gemini.apiKey } : {}),
+    };
+  }
   const scripted = config as Extract<EngineOption, { kind: 'scripted' }>;
   return {
     kind: 'scripted',
@@ -139,6 +149,21 @@ function wireToEngineOption(wire: AiEngineConfigWire): EngineOption {
       ...(wire.modelMap !== undefined ? { modelMap: wire.modelMap } : {}),
     } as EngineOption;
   }
+  const isGeminiWire = wire.kind === 'gemini';
+  if (isGeminiWire) {
+    const result: Record<string, unknown> = {
+      kind: 'gemini',
+    };
+    const hasBaseUrl = wire.baseUrl !== undefined;
+    if (hasBaseUrl) {
+      result.baseUrl = wire.baseUrl;
+    }
+    const hasApiKey = wire.apiKey !== undefined;
+    if (hasApiKey) {
+      result.apiKey = wire.apiKey;
+    }
+    return result as unknown as EngineOption;
+  }
   return {
     kind: 'scripted',
     ...(wire.script !== undefined
@@ -274,10 +299,11 @@ export const getAI = (
               "Use a structured { kind: 'scripted' } or { kind: 'openai' } engine config.",
           );
         }
+        const wire = toEngineWire(engine) ?? pluginEngineWire();
         return createTransportAI(
           resolved,
           options,
-          portEngine(workerClientForApp(resolved), toEngineWire(engine)),
+          portEngine(workerClientForApp(resolved), wire),
           assertAlive,
         );
       }

package/src/serve/entries/auth-helper-core.ts

@@ -86,6 +86,11 @@ export class ServeAuthHelper {
     return { openPopup: open, openRedirect: open };
   }
 
+  promptCreateUser(providerId = 'password'): Promise<UserCredential> {
+    const open = this.resolver().openPopup;
+    return open({ providerId, authType: 'signIn' });
+  }
+
   subscribe(fn: () => void): () => void {
     this.listeners.add(fn);
     return () => this.listeners.delete(fn);

package/src/serve/entries/auth-helper-dom.ts

@@ -19,8 +19,24 @@ const PROVIDER_LABEL: Record<string, string> = {
 };
 
 const STYLE = `
-  dialog[data-pyric-auth] { border: 1px solid #2a2a35; border-radius: 12px; background: #16161d;
-    color: #e8e8ee; font: 14px/1.45 system-ui, sans-serif; padding: 20px; width: min(420px, 92vw); }
+  dialog[data-pyric-auth] {
+    position: fixed;
+    top: 50%;
+    left: 50%;
+    transform: translate(-50%, -50%);
+    margin: 0;
+    width: min(420px, 92vw);
+    max-height: 90vh;
+    overflow-y: auto;
+    border: 1px solid #2a2a35;
+    border-radius: 12px;
+    background: #16161d;
+    color: #e8e8ee;
+    font: 14px/1.45 system-ui, sans-serif;
+    padding: 20px;
+    box-shadow: 0 20px 60px rgba(0, 0, 0, 0.6);
+    z-index: 2147483647;
+  }
   dialog[data-pyric-auth]::backdrop { background: rgb(0 0 0 / 0.6); }
   dialog[data-pyric-auth] h2 { margin: 0 0 4px; font-size: 16px; }
   dialog[data-pyric-auth] p { margin: 0 0 14px; font-size: 12px; color: #9a9aa8; }
@@ -61,13 +77,18 @@ export function mountAuthHelperDialog(helper: ServeAuthHelper): void {
       return;
     }
     const provider = PROVIDER_LABEL[snap.request.providerId] ?? snap.request.providerId;
+    const existingForm = dialog.querySelector('form');
+    const savedEmail = existingForm?.querySelector<HTMLInputElement>('input[type="email"]')?.value;
+    const savedName = existingForm?.querySelector<HTMLInputElement>('input[type="text"]')?.value;
+    const savedClaims = existingForm?.querySelector<HTMLTextAreaElement>('textarea')?.value;
+
     dialog.replaceChildren();
 
     const h2 = document.createElement('h2');
     h2.textContent = `Sign in with ${provider}`;
     const p = document.createElement('p');
     p.textContent =
-      'pyric dev sign-in helper — pick a test account or add one. Custom claims let rules using request.auth.token.* run against this identity.';
+      'pyric sandbox sign-in helper. Pick a test account or add one. Custom claims let rules using request.auth.token.* run against this identity.';
     dialog.append(h2, p);
 
     if (snap.identities.length > 0) {
@@ -90,12 +111,15 @@ export function mountAuthHelperDialog(helper: ServeAuthHelper): void {
     email.type = 'email';
     email.placeholder = 'email@example.com';
     email.required = true;
+    if (savedEmail) email.value = savedEmail;
     const name = document.createElement('input');
     name.type = 'text';
     name.placeholder = 'Display name (optional)';
+    if (savedName) name.value = savedName;
     const claims = document.createElement('textarea');
     claims.rows = 3;
     claims.placeholder = 'Custom claims JSON (optional)\ne.g. { "admin": true }';
+    if (savedClaims) claims.value = savedClaims;
     const err = document.createElement('div');
     err.className = 'err';
     const row = document.createElement('div');

package/src/serve/entries/auth-helper-runtime.ts

@@ -13,7 +13,7 @@ export function resolveServeAuthFlow(
 ): Promise<UserCredential> {
   if (!resolver) {
     return Promise.reject(
-      new Error('pyric dev provider helper is not initialized; load /__pyric/sdk/init.js first'),
+      new Error('pyric sandbox provider helper is not initialized; load /__pyric/sdk/init.js first'),
     );
   }
   return kind === 'popup' ? resolver.openPopup(request) : resolver.openRedirect(request);

package/src/serve/entries/auth.ts

@@ -24,7 +24,9 @@ import { customClaimsFromTokenClaims } from './auth-helper-core.js';
 import { resolveServeAuthFlow } from './auth-helper-runtime.js';
 import type { SessionMode } from './session-store.js';
 import { getApp, type FirebaseApp } from 'pyric/app';
+import { registerAppCleanup } from 'pyric/app/internal';
 import { workerClientForApp } from './app-client.js';
+import { registerActiveAuth } from './active-auth.js';
 
 // Worker-client auth, cast to the canonical pyric/auth surface for the picked
 // bindings (same names + shapes). Provider-bridge specifics are explicit below.
@@ -101,6 +103,8 @@ export const getAuth = ((app?: FirebaseApp) => {
   if (!useWorker) {
     const handle = pyricGetAuth(resolved);
     wireAppPersistence(resolved, handle);
+    const releaseActiveAuth = registerActiveAuth(handle);
+    registerAppCleanup(resolved, releaseActiveAuth);
     return handle;
   }
   const existing = workerAuthByApp.get(resolved);
@@ -111,6 +115,10 @@ export const getAuth = ((app?: FirebaseApp) => {
   }) as unknown as ReturnType<typeof pyricGetAuth>;
   workerAuthByApp.set(resolved, handle);
   wireAppPersistence(resolved, handle);
+  const releaseActiveAuth = registerActiveAuth(handle);
+  // Match Firebase's cached-service lifecycle: getAuth(deletedApp) still
+  // returns its existing handle, but that handle no longer joins chip fan-out.
+  registerAppCleanup(resolved, releaseActiveAuth);
   return handle;
 }) as typeof pyricGetAuth;
 

package/src/serve/entries/bridge-url.ts

@@ -1,7 +1,7 @@
 /**
  * Re-anchor a bridge WebSocket URL to the page's own origin.
  *
- * `pyric dev` / the vite plugin bake their OWN host into the bridge URL it
+ * `pyric sandbox` / the vite plugin bake their OWN host into the bridge URL it
  * sends the page (e.g. `ws://localhost:5173/__pyric/sandbox`). But the page may
  * have been loaded over a different host (Tailscale, a LAN IP) or scheme
  * (`https` via `tailscale serve`, which then requires `wss`). Connecting to the

package/src/serve/entries/firestore.ts

@@ -103,8 +103,8 @@ function acceptedNoOp(name: string): void {
   if (cacheNoticeShown) return;
   cacheNoticeShown = true;
   console.info(
-    `[pyric dev] ${name}(): client cache/persistence settings are accepted but unused — ` +
-      'the pyric sandbox is the source of truth. Durable state is the worker store / `pyric dev --persist`.',
+    `[pyric sandbox] ${name}(): client cache and persistence settings are accepted but unused. ` +
+      'The Pyric sandbox is the source of truth. Durable state is the worker store or `pyric sandbox --persist`.',
   );
 }
 
@@ -184,7 +184,7 @@ export async function enableNetwork(_db?: unknown): Promise<void> {
 export async function terminate(db?: unknown): Promise<void> {
   if (useWorker) {
     console.info(
-      '[pyric dev] terminate(): the SharedWorker-hosted sandbox is shared across every tab; ' +
+      '[pyric sandbox] terminate(): the SharedWorker-hosted sandbox is shared across every tab; ' +
         'it is not torn down by a single tab calling terminate().',
     );
     return;

package/src/serve/entries/init.ts

@@ -5,21 +5,36 @@
  * only; in fallback mode it mints credentials via `createSignInCredential`
  * so OAuth users carry real provider metadata.
  */
-import { getAuth, sandbox as authSandbox } from 'pyric/auth';
+import {
+  getAuth,
+  sandbox as authSandbox,
+} from 'pyric/auth';
 import {
   getAuth as getWorkerAuth,
   listUsers,
+  setLens,
 } from '../worker/client.js';
+import {
+  switchAllAuthUsers,
+  signOutAllAuths,
+  commitCredentialToAllAuths,
+  getActiveAuthUser,
+  subscribeToActiveAuth,
+  registerActiveAuth,
+} from './active-auth.js';
 import { sandbox } from './runtime.js';
 import { useWorker, workerDb } from './worker-runtime.js';
-import { ServeAuthHelper } from './auth-helper-core.js';
+import { ServeAuthHelper, customClaimsFromTokenClaims } from './auth-helper-core.js';
 import { installServeAuthResolver } from './auth-helper-runtime.js';
 import { mountAuthHelperDialog } from './auth-helper-dom.js';
 import { installPyricRuntimeChip } from '../runtime/chip-install.js';
 import { getPyricRuntimeStatus } from '../runtime/status.js';
+import { projectRuntimeIdentity } from '../runtime/identity.js';
 
 const localAuth = useWorker ? null : getAuth(sandbox);
 const workerAuth = useWorker && workerDb ? getWorkerAuth(workerDb) : null;
+if (workerAuth) registerActiveAuth(workerAuth);
+if (localAuth) registerActiveAuth(localAuth);
 const helper = workerAuth
   ? new ServeAuthHelper({
       list: async () => (await listUsers(workerAuth)).map((user) => ({
@@ -56,7 +71,67 @@ if (localAuth) authSandbox.setAuthFlowResolver(localAuth, resolver);
 
 if (typeof document !== 'undefined' && typeof window !== 'undefined') {
   mountAuthHelperDialog(helper);
-  installPyricRuntimeChip({ runtime: getPyricRuntimeStatus(), document });
+  installPyricRuntimeChip({
+    runtime: getPyricRuntimeStatus(),
+    document,
+    identity: {
+      listUsers: async () => {
+        if (workerAuth) {
+          return listUsers(workerAuth);
+        }
+        if (localAuth) {
+          return authSandbox.listUsers(localAuth);
+        }
+        return [];
+      },
+      switchUser: async (uid: string) => {
+        await switchAllAuthUsers(uid);
+        setLens(undefined);
+      },
+      signOut: async () => {
+        await signOutAllAuths();
+        setLens(undefined);
+      },
+      openCreateUser: async () => {
+        try {
+          const cred = await helper.promptCreateUser('password');
+          const tokenResult = await cred.user.getIdTokenResult();
+          const customClaims = customClaimsFromTokenClaims(
+            (tokenResult.claims ?? {}) as Record<string, unknown>,
+          );
+          const identity = {
+            uid: cred.user.uid,
+            email: cred.user.email,
+            displayName: cred.user.displayName,
+            customClaims,
+            providerId: 'password',
+          };
+          await commitCredentialToAllAuths(identity);
+          await switchAllAuthUsers(identity.uid);
+          setLens(undefined);
+        } catch (err) {
+          console.error('[pyric] openCreateUser error:', err);
+        }
+      },
+      getCurrentUser: () => {
+        const active = getActiveAuthUser();
+        if (active) return active;
+        if (workerAuth?.currentUser) {
+          return projectRuntimeIdentity(workerAuth.currentUser);
+        }
+        if (localAuth?.currentUser) {
+          return projectRuntimeIdentity(localAuth.currentUser);
+        }
+        return null;
+      },
+      subscribeAuth: (listener) => {
+        const unsubActive = subscribeToActiveAuth((user) => {
+          listener(projectRuntimeIdentity(user));
+        });
+        return unsubActive;
+      },
+    },
+  });
 }
 
 export {};

package/src/serve/entries/keepalive.ts

@@ -27,7 +27,7 @@ export function keepaliveSafe(
   if (!warnedLargeState) {
     warnedLargeState = true;
     warn(
-      `[pyric dev] persisted state is ${Math.round(bytes / 1024)}KB — too large for an ` +
+      `[pyric sandbox] persisted state is ${Math.round(bytes / 1024)}KB. It is too large for an ` +
         'unload-time flush; the final unsaved change may be lost if you CLOSE the tab before ' +
         'the next auto-flush. Reloads and normal saves are unaffected.',
     );

package/src/serve/entries/runtime.ts

@@ -34,6 +34,7 @@ import { toPageOriginWsUrl } from './bridge-url.js';
 import { buildVerifyFixture } from '../../verify/fixture.js';
 import type { InitPayload } from '../init-payload.js';
 import { setupFirebaseActivityGuard } from '../activity-guard.js';
+import { setupAiDiagnosticsRelay } from '../ai-diagnostics-relay.js';
 import { getPyricRuntimeStatus } from '../runtime/status.js';
 export { sandbox } from './app-backend.js';
 import { sandbox } from './app-backend.js';
@@ -140,10 +141,15 @@ if (!useWorker) try {
     diagnostics.rulesDeployed = true;
     diagnostics.rulesHash = payload.rulesHash;
   }
+  const db = getDatabase(sandbox);
   if (payload.databaseRules) {
-    rtdbSandbox.setRules(getDatabase(sandbox), payload.databaseRules);
+    rtdbSandbox.setRules(db, payload.databaseRules);
     diagnostics.databaseRulesDeployed = true;
     diagnostics.databaseRulesHash = payload.databaseRulesHash ?? null;
+  } else if (payload.permissive) {
+    rtdbSandbox.setDefaultPolicy(db, 'allow');
+  } else {
+    rtdbSandbox.setDefaultPolicy(db, 'deny');
   }
   // Open the ONE per-sandbox storage service eagerly: the FIRST open wins the
   // rules AND the project-scoped IDB name (`pyric-storage:<projectKey>`,
@@ -212,7 +218,7 @@ if (!useWorker) try {
       readOnly = true;
       diagnostics.persistReadOnly = true;
       console.warn(
-        '[pyric dev] another tab is the persist writer — THIS tab is read-only ' +
+        '[pyric sandbox] another tab is the persist writer. This tab is read-only ' +
           '(your changes here will NOT be saved). Close the other tab and reload to take over.',
       );
     };
@@ -288,7 +294,7 @@ if (!useWorker) try {
             if (res.status === 423) lostWriterLock();
             else if (res.ok) diagnostics.lastFlushAt = Date.now();
           },
-          (e) => console.warn('[pyric dev] auth state flush failed:', e),
+          (e) => console.warn('[pyric sandbox] auth state flush failed:', e),
         );
       }, 500);
     });
@@ -353,7 +359,7 @@ if (!useWorker) try {
     if (existing) {
       diagnostics.seedSkipped = true;
       console.info(
-        '[pyric dev] --seed skipped: the sandbox already has restored data — the fixture would ' +
+        '[pyric sandbox] --seed skipped because the sandbox already has restored data. The fixture would ' +
           'have overwritten it. Use `--persist --fresh` to discard existing state and re-seed.',
       );
     } else {
@@ -367,7 +373,7 @@ if (!useWorker) try {
   diagnostics.initError = e instanceof Error ? e.message : String(e);
   runtimeStatus.reportError(e, 'runtime');
   console.error(
-    '[pyric dev] init failed — the sandbox is running WITHOUT your project rules:',
+    '[pyric sandbox] init failed. The sandbox is running without your project rules:',
     diagnostics.initError,
   );
 }
@@ -386,11 +392,20 @@ if (!useWorker && activityTokenFromPayload) {
   );
 }
 
+// Same plane split for the AI broker's diagnostics: an in-page sandbox runs
+// its own broker, so its `request_rejected`, `response_blocked`, and
+// `model_substituted` events need the same relay to reach the dev terminal.
+// Unlike the activity guard this needs no capability token (the denial relay
+// it rides carries none).
+if (!useWorker) {
+  setupAiDiagnosticsRelay({ subscribe: (listener) => sandbox.onEvent(listener) }, fetch);
+}
+
 // ── provenance (flow doc section 3a): make the shim's presence unmistakable.
 // Source says `firebase/*`; what runs is the pyric sandbox — say so loudly
 // once, and explain any stack frame that points into /__pyric/sdk/. ────────
 console.info(
-  `[pyric dev] firebase/* on this page is served by the pyric sandbox` +
+  `[pyric sandbox] firebase/* on this page is served by the Pyric sandbox` +
     (useWorker
       ? ' in a SharedWorker (one backend for all tabs; rules/seed/persist owned by the worker)'
       : diagnostics.rulesHash || diagnostics.databaseRulesHash || diagnostics.storageRulesHash
@@ -405,7 +420,7 @@ function explainSandboxFrame(stackOrUrl: string | undefined): boolean {
   if (!provenanceHintShown) {
     provenanceHintShown = true;
     console.info(
-      '[pyric dev] the error above originates in the pyric sandbox shim serving firebase/*, ' +
+      '[pyric sandbox] the error above originates in the Pyric sandbox shim serving firebase/*, ' +
         'not the real Firebase SDK — behavior can differ where COMPAT coverage is incomplete.',
     );
   }
@@ -452,7 +467,7 @@ async function connectBridgePeer(rawUrl: string): Promise<void> {
     connectBridge(sandbox, { url });
   }
   diagnostics.bridgeConnected = true;
-  console.info('[pyric dev] sandbox registered with the MCP bridge at', url);
+  console.info('[pyric sandbox] sandbox registered with the MCP bridge at', url);
 }
 if (bridgeUrlFromPayload) {
   // In-page path: bridgeUrlFromPayload came from the (already-blocking) init
@@ -461,7 +476,7 @@ if (bridgeUrlFromPayload) {
     await connectBridgePeer(bridgeUrlFromPayload);
   } catch (e) {
     runtimeStatus.reportError(e, 'runtime');
-    console.error('[pyric dev] bridge connect failed:', e instanceof Error ? e.message : String(e));
+    console.error('[pyric sandbox] bridge connect failed:', e instanceof Error ? e.message : String(e));
   }
 } else if (useWorker) {
   // Worker path: the worker owns serve-init, so the page skipped the init.json
@@ -476,7 +491,7 @@ if (bridgeUrlFromPayload) {
       if (url) await connectBridgePeer(url);
     } catch (e) {
       runtimeStatus.reportError(e, 'runtime');
-      console.error('[pyric dev] bridge connect failed:', e instanceof Error ? e.message : String(e));
+      console.error('[pyric sandbox] bridge connect failed:', e instanceof Error ? e.message : String(e));
     }
   })();
 }
@@ -547,10 +562,10 @@ if (!useWorker && typeof EventSource !== 'undefined') {
       if (lint.parseError) throw new Error(JSON.stringify(lint.parseError));
       diagnostics.rulesDeployed = true;
       diagnostics.rulesHash = rulesHash;
-      console.info(`[pyric dev] firestore.rules hot-reloaded (hash ${rulesHash})`);
+      console.info(`[pyric sandbox] firestore.rules hot-reloaded (hash ${rulesHash})`);
     } catch (err) {
       runtimeStatus.reportError(err, 'runtime');
-      console.error('[pyric dev] rules hot-reload failed:', err instanceof Error ? err.message : String(err));
+      console.error('[pyric sandbox] rules hot-reload failed:', err instanceof Error ? err.message : String(err));
     }
   });
   events.addEventListener('rtdb-rules-update', (e) => {
@@ -567,7 +582,7 @@ if (!useWorker && typeof EventSource !== 'undefined') {
         newHash = rulesHash;
       }
       diagnostics.databaseRulesHash = newHash;
-      console.info(`[pyric dev] database.rules.json hot-reloaded (hash ${rulesHash})`);
+      console.info(`[pyric sandbox] database.rules.json hot-reloaded (hash ${rulesHash})`);
     } catch (err) {
       runtimeStatus.reportError(err, 'runtime');
       const isErrorInstance = err instanceof Error;
@@ -575,7 +590,7 @@ if (!useWorker && typeof EventSource !== 'undefined') {
       if (isErrorInstance) {
         errorMessage = (err as Error).message;
       }
-      console.error('[pyric dev] database rules hot-reload failed:', errorMessage);
+      console.error('[pyric sandbox] database rules hot-reload failed:', errorMessage);
     }
   });
 }

package/src/serve/entries/storage.ts

@@ -66,7 +66,7 @@ export function connectStorageEmulator(
   _options?: unknown,
 ): void {
   console.info(
-    '[pyric dev] pyric replaces the Firebase emulator; connectStorageEmulator is a no-op.',
+    '[pyric sandbox] Pyric replaces the Firebase emulator; connectStorageEmulator is a no-op.',
   );
   if (!useWorker) ip.connectStorageEmulator(storage as FirebaseStorage, _host, _port, _options as never);
 }

package/src/serve/entries/worker-runtime.ts

@@ -125,7 +125,7 @@ if (useWorker && typeof document !== 'undefined') {
           ? ' This is the only connected page — reload it to pick up the new worker.'
           : '';
       console.warn(
-        `[pyric dev] the SharedWorker is running OLDER code (build ${runningVersion}) than what is now `
+        `[pyric sandbox] the SharedWorker is running older code (build ${runningVersion}) than what is now `
           + `served (build ${servedVersion}). A SharedWorker can't hot-update — CLOSE ALL TABS of this origin `
           + 'and reopen to load the new worker. (All tabs share one worker, so a partial reload leaves '
           + `the old code running for everyone.)${othersHint}`,

package/src/serve/init-payload.ts

@@ -4,11 +4,15 @@ import type { AiEngineConfigWire } from './worker/protocol.js';
 export interface InitPayload {
   /** Per-server capability for the warning-only activity report endpoint. */
   activityToken?: string;
+  /** Per-boot session capability token required on workspace and project endpoints. */
+  sessionToken?: string;
   rules: string | null;
   rulesHash: string | null;
   databaseRules?: { rules: Record<string, unknown> } | null;
   databaseRulesHash?: string | null;
   databaseUrl?: string | null;
+  /** Explicit opt-in to permissive default access when rules are unconfigured. */
+  permissive?: boolean;
   /** Storage rules are installed once, before the first Storage operation. */
   storageRules: string | null;
   storageRulesHash: string | null;