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

package/src/serve/bundler.ts

@@ -52,7 +52,7 @@ export function defaultSdkEntries(): Record<string, string> {
     if (existsSync(js)) return js;
     const ts = join(here, 'entries', `${name}.ts`);
     if (existsSync(ts)) return ts;
-    throw new Error(`pyric dev: missing SDK entry '${name}' next to ${here}`);
+    throw new Error(`pyric sandbox: missing SDK entry '${name}' next to ${here}`);
   };
   return {
     ai: pick('ai'),
@@ -94,7 +94,7 @@ export function pyricPackageRoot(): string {
   }
   const pkg = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8')) as { name?: string };
   if (pkg.name !== 'pyric') {
-    throw new Error(`pyric dev: expected to resolve the pyric package, found '${pkg.name}' at ${dir}`);
+    throw new Error(`pyric sandbox: expected to resolve the pyric package, found '${pkg.name}' at ${dir}`);
   }
   return dir;
 }
@@ -131,7 +131,7 @@ export const NODE_BUILTIN_RE = /^(node:)?(url|fs|path)$/;
  *  through its own resolveId/load + optimizeDeps esbuild pass, instead of
  *  re-deriving them. */
 export const NODE_BUILTIN_SHIMS: Record<string, string> = {
-  fs: `const no = () => { throw new Error('pyric dev: fs is not available in the browser'); };
+  fs: `const no = () => { throw new Error('pyric sandbox: fs is not available in the browser'); };
 export const readFileSync = no; export const existsSync = () => false;
 export const readdirSync = no; export const writeFileSync = no; export const mkdirSync = no;
 export default { readFileSync, existsSync, readdirSync, writeFileSync, mkdirSync };`,
@@ -315,13 +315,13 @@ export async function bundleSdk(opts: BundleOptions): Promise<BundleResult> {
       // self-identify as the sandbox shim, not the real Firebase SDK.
       chunkNames: 'pyric-sandbox-[hash]',
       banner: {
-        js: '/* pyric dev: pyric sandbox shim serving firebase/* — NOT the real Firebase SDK */',
+        js: '/* pyric sandbox shim serving firebase/*. This is not the real Firebase SDK. */',
       },
       plugins: [pyricResolvePlugin(), nodeShimPlugin()],
     });
     if (result.errors.length > 0) {
       throw new Error(
-        `pyric dev: SDK bundle failed:\n${result.errors.map((e) => e.text).join('\n')}`,
+        `pyric sandbox: SDK bundle failed:\n${result.errors.map((e) => e.text).join('\n')}`,
       );
     }
     writeFileSync(join(outDir, '.complete'), new Date().toISOString());
@@ -348,7 +348,7 @@ export function workerEntryPath(): string {
   if (existsSync(js)) return js;
   const ts = join(here, 'worker', 'entry.ts');
   if (existsSync(ts)) return ts;
-  throw new Error(`pyric dev: missing SharedWorker entry next to ${here}`);
+  throw new Error(`pyric sandbox: missing SharedWorker entry next to ${here}`);
 }
 
 export interface WorkerBundleOptions {
@@ -371,7 +371,7 @@ const WORKER_EPOCH_FILE = '.worker-epoch';
 function readWorkerBundleEpoch(outDir: string): string {
   const epoch = readFileSync(join(outDir, WORKER_EPOCH_FILE), 'utf8').trim();
   if (!/^[a-f0-9]{16}$/.test(epoch)) {
-    throw new Error(`pyric dev: invalid SharedWorker epoch in ${join(outDir, WORKER_EPOCH_FILE)}`);
+    throw new Error(`pyric sandbox: invalid SharedWorker epoch in ${join(outDir, WORKER_EPOCH_FILE)}`);
   }
   return epoch;
 }
@@ -479,18 +479,18 @@ export async function bundleWorker(opts: WorkerBundleOptions): Promise<WorkerBun
     // with the resulting epoch (same width, so the sourcemap stays aligned).
     define: { __PYRIC_WORKER_VERSION__: JSON.stringify(WORKER_EPOCH_PLACEHOLDER) },
     banner: {
-      js: '/* pyric dev: SharedWorker sandbox host serving firebase/* — NOT the real Firebase SDK */',
+      js: '/* pyric sandbox SharedWorker host serving firebase/*. This is not the real Firebase SDK. */',
     },
     plugins: [pyricResolvePlugin(), nodeShimPlugin()],
   });
   if (result.errors.length > 0) {
     throw new Error(
-      `pyric dev: SharedWorker bundle failed:\n${result.errors.map((e) => e.text).join('\n')}`,
+      `pyric sandbox: SharedWorker bundle failed:\n${result.errors.map((e) => e.text).join('\n')}`,
     );
   }
   const canonicalSource = readFileSync(outFile, 'utf8');
   if (!canonicalSource.includes(WORKER_EPOCH_PLACEHOLDER)) {
-    throw new Error('pyric dev: SharedWorker bundle omitted its epoch placeholder');
+    throw new Error('pyric sandbox: SharedWorker bundle omitted its epoch placeholder');
   }
   const epochHash = createHash('sha256').update(canonicalSource);
   if (opts.epochSalt) epochHash.update('\0').update(opts.epochSalt);

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-dom.ts

@@ -67,7 +67,7 @@ export function mountAuthHelperDialog(helper: ServeAuthHelper): void {
     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) {

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/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/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

@@ -140,10 +140,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 +217,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 +293,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 +358,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 +372,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,
   );
 }
@@ -390,7 +395,7 @@ if (!useWorker && activityTokenFromPayload) {
 // 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 +410,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 +457,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 +466,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 +481,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 +552,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 +572,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 +580,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;

package/src/serve/namespace.ts

@@ -18,7 +18,7 @@ import { collectBody } from '../bridge/server/peer.js';
 import { StateFileError, type StateSection, type StateStore } from './state-store.js';
 import { createWriterLock, type WriterLock } from './writer-lock.js';
 import { createStudioRoutes, type StudioRouteOptions } from './studio/index.js';
-import { pipeFileToResponse, type ServeLogger } from './server.js';
+import { pipeFileToResponse, getHeader, isAllowedHost, isAllowedOrigin, type ServeLogger } from './server.js';
 import type { InitPayload } from './init-payload.js';
 import { handleActivity } from './activity-route.js';
 import { createSiteTreeHandler } from './site-tree.js';
@@ -107,6 +107,12 @@ export interface NamespaceOptions {
    *  (disk-backed `WorkspaceStore`/`ProjectStore`, plus the SSE watch stream)
    *  that `@pyric/studio`'s `local` mode talks to. */
   studio?: StudioRouteOptions;
+  /** Per-boot session capability token required on workspace and project endpoints. */
+  sessionToken?: string;
+  /** Bound host for DNS rebinding guard. */
+  boundHost?: string;
+  /** Extra allowed hostnames. */
+  allowedHosts?: string[];
   /** The OpenAI-compatible upstream `/__pyric/ai-proxy` forwards to
    *  (pyric/ai — cdd-deltas #98.2). Falls back to the
    *  `PYRIC_AI_PROXY_UPSTREAM` env var, then `http://localhost:11434/v1`
@@ -471,8 +477,20 @@ async function handleDenials(
 }
 
 export function createPyricNamespace(opts: NamespaceOptions) {
-  const writerLock = createWriterLock();
-  const studioRoutes = opts.studio ? createStudioRoutes(opts.studio) : null;
+  const stateWriterLock = createWriterLock();
+  const studioWriterLock = opts.studio?.writerLock ?? createWriterLock();
+  const sessionToken = opts.sessionToken ?? randomBytes(24).toString('base64url');
+  let studioRoutes: ((req: IncomingMessage, res: ServerResponse, url: URL) => Promise<boolean>) | null = null;
+  if (opts.studio) {
+    const studioOptions: StudioRouteOptions = {
+      ...opts.studio,
+      sessionToken,
+      writerLock: studioWriterLock,
+      boundHost: opts.boundHost,
+      allowedHosts: opts.allowedHosts,
+    };
+    studioRoutes = createStudioRoutes(studioOptions);
+  }
   const siteTree = opts.siteUiDir
     ? createSiteTreeHandler(opts.siteUiDir, opts.workerVersion)
     : null;
@@ -489,7 +507,7 @@ export function createPyricNamespace(opts: NamespaceOptions) {
       return studioRoutes(req, res, url);
     }
     if (opts.state && url.pathname === '/__pyric/state') {
-      return handleState(opts.state!, writerLock, req, res, url).then(() => true);
+      return handleState(opts.state!, stateWriterLock, req, res, url).then(() => true);
     }
     if (opts.capture && url.pathname === '/__pyric/capture') {
       return handleCapture(opts.capture, req, res).then(() => true);
@@ -498,6 +516,21 @@ export function createPyricNamespace(opts: NamespaceOptions) {
       return handleActivity(opts.activity, req, res, activityToken!).then(() => true);
     }
     if (opts.events && url.pathname === '/__pyric/events') {
+      const hostHeader = getHeader(req, 'host');
+      const originHeader = getHeader(req, 'origin');
+      if (!isAllowedHost(hostHeader, opts.boundHost ?? 'localhost', opts.allowedHosts)) {
+        res.writeHead(403, { 'content-type': 'text/plain' }).end('Forbidden: host not allowed');
+        return true;
+      }
+      if (originHeader && !isAllowedOrigin(originHeader, opts.boundHost ?? 'localhost', opts.allowedHosts)) {
+        res.writeHead(403, { 'content-type': 'text/plain' }).end('Forbidden: origin mismatch');
+        return true;
+      }
+      const reqToken = getHeader(req, 'x-pyric-session-token') ?? url.searchParams.get('token');
+      if (sessionToken && reqToken && reqToken !== sessionToken) {
+        res.writeHead(401, { 'content-type': 'text/plain' }).end('Unauthorized: invalid session capability token');
+        return true;
+      }
       opts.events.handle(req, res);
       return true;
     }
@@ -509,7 +542,13 @@ export function createPyricNamespace(opts: NamespaceOptions) {
     }
     if (url.pathname === '/__pyric/init.json') {
       res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', 'cache-control': 'no-store' });
-      res.end(JSON.stringify({ ...opts.initPayload(), ...(activityToken ? { activityToken } : {}) }));
+      res.end(
+        JSON.stringify({
+          ...opts.initPayload(),
+          sessionToken,
+          ...(activityToken ? { activityToken } : {}),
+        }),
+      );
       return true;
     }
     if (url.pathname.startsWith('/__pyric/sdk/')) {

package/src/serve/rules.ts

@@ -56,7 +56,7 @@ export function prepareRulesSource(raw: string, sourcePath: string): string {
     const resolved = resolveModulesBrowser(raw);
     if (!resolved.success) {
       throw new Error(
-        `pyric dev: ${sourcePath} uses 2+modules but module resolution failed: ${resolved.error.message}`,
+        `pyric sandbox: ${sourcePath} uses 2+modules but module resolution failed: ${resolved.error.message}`,
       );
     }
     source = resolved.data.resolved;
@@ -65,13 +65,13 @@ export function prepareRulesSource(raw: string, sourcePath: string): string {
   if (lint.parseError) {
     const { line, column } = lint.parseError;
     throw new Error(
-      `pyric dev: ${sourcePath} failed to parse (line ${line}, col ${column}) — fix the rules before serving.`,
+      `pyric sandbox: ${sourcePath} failed to parse (line ${line}, col ${column}). Fix the rules before serving.`,
     );
   }
   const errors = lint.warnings.filter((w) => w.severity === 'error');
   if (errors.length > 0) {
     throw new Error(
-      `pyric dev: ${sourcePath} has ${errors.length} rules error(s):\n` +
+      `pyric sandbox: ${sourcePath} has ${errors.length} rules error(s):\n` +
         errors.map((e) => `  - ${e.message}`).join('\n'),
     );
   }
@@ -98,7 +98,7 @@ export async function loadProjectRules(
   } catch (e) {
     if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
       if (configured) {
-        throw new Error(`pyric dev: firebase.json points firestore.rules at ${path}, but it does not exist.`);
+        throw new Error(`pyric sandbox: firebase.json points firestore.rules at ${path}, but it does not exist.`);
       }
       return { rules: null, rulesHash: null, sourcePath: null };
     }
@@ -119,7 +119,7 @@ export function prepareStorageRulesSource(raw: string, sourcePath: string): stri
     const resolved = resolveModulesBrowser(raw, { sourceFile: sourcePath });
     if (!resolved.success) {
       throw new Error(
-        `pyric dev: ${sourcePath} uses 2+modules but module resolution failed: ${resolved.error.message}`,
+        `pyric sandbox: ${sourcePath} uses 2+modules but module resolution failed: ${resolved.error.message}`,
       );
     }
     source = resolved.data.resolved;
@@ -128,7 +128,7 @@ export function prepareStorageRulesSource(raw: string, sourcePath: string): stri
     parseStorageRules(source);
   } catch (e) {
     throw new Error(
-      `pyric dev: ${sourcePath} failed to parse: ${e instanceof Error ? e.message : String(e)} — fix the rules before serving.`,
+      `pyric sandbox: ${sourcePath} failed to parse: ${e instanceof Error ? e.message : String(e)}. Fix the rules before serving.`,
     );
   }
   return source;
@@ -159,7 +159,7 @@ export async function loadProjectStorageRules(
   } catch (e) {
     if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
       if (configured) {
-        throw new Error(`pyric dev: firebase.json points storage.rules at ${path}, but it does not exist.`);
+        throw new Error(`pyric sandbox: firebase.json points storage.rules at ${path}, but it does not exist.`);
       }
       return { rules: null, rulesHash: null, sourcePath: null };
     }
@@ -169,27 +169,52 @@ export async function loadProjectStorageRules(
   return { rules, rulesHash: rulesHashOf(rules), sourcePath: path };
 }
 
+function normalizeDatabaseEntries(block: unknown): Array<Record<string, unknown>> {
+  if (!block) {
+    return [];
+  }
+  if (Array.isArray(block)) {
+    return block.filter((item): item is Record<string, unknown> => typeof item === 'object' && item !== null);
+  }
+  if (typeof block === 'object' && block !== null) {
+    return [block as Record<string, unknown>];
+  }
+  return [];
+}
+
+function hasConfiguredRules(entry: Record<string, unknown>): entry is Record<string, unknown> & { rules: string } {
+  return typeof entry.rules === 'string';
+}
+
+function hasConfiguredUrl(entry: Record<string, unknown>): entry is Record<string, unknown> & { url: string } {
+  return typeof entry.url === 'string';
+}
+
 export async function loadProjectDatabaseRules(
   cwd: string,
   config: FirebaseJson | null,
 ): Promise<LoadedDatabaseRules> {
-  const configured = config?.database?.rules;
-  if (!configured) {
-    return {
-      rules: null,
-      rulesHash: null,
-      sourcePath: null,
-      databaseUrl: config?.database?.url ?? null,
-    };
-  }
-
-  const path = isAbsolute(configured) ? configured : join(cwd, configured);
+  const entries = normalizeDatabaseEntries(config?.database);
+  const configuredEntry = entries.find(hasConfiguredRules);
+  const configured = configuredEntry?.rules;
+  const rel = configured ?? 'database.rules.json';
+  const path = isAbsolute(rel) ? rel : join(cwd, rel);
+  const urlEntry = entries.find(hasConfiguredUrl);
+  const databaseUrl = urlEntry?.url ?? null;
   let raw: string;
   try {
     raw = await readFile(path, 'utf8');
   } catch (e) {
     if ((e as NodeJS.ErrnoException).code === 'ENOENT') {
-      throw new Error(`pyric dev: firebase.json points database.rules at ${path}, but it does not exist.`);
+      if (configured) {
+        throw new Error(`pyric sandbox: firebase.json points database.rules at ${path}, but it does not exist.`);
+      }
+      return {
+        rules: null,
+        rulesHash: null,
+        sourcePath: null,
+        databaseUrl,
+      };
     }
     throw e;
   }
@@ -198,18 +223,18 @@ export async function loadProjectDatabaseRules(
   try {
     parsed = JSON.parse(stripJsonComments(raw));
   } catch (e) {
-    throw new Error(`pyric dev: ${path} failed to parse as RTDB rules JSON: ${e instanceof Error ? e.message : String(e)}`);
+    throw new Error(`pyric sandbox: ${path} failed to parse as RTDB rules JSON: ${e instanceof Error ? e.message : String(e)}`);
   }
   const rules = parseRtdbRulesJson(
     parsed,
-    () => new Error(`pyric dev: ${path} must contain a top-level "rules" object.`),
+    () => new Error(`pyric sandbox: ${path} must contain a top-level "rules" object.`),
   );
 
   return {
     rules,
     rulesHash: rulesHashOf(raw),
     sourcePath: path,
-    databaseUrl: config?.database?.url ?? null,
+    databaseUrl,
   };
 }
 

package/src/serve/runtime/chip.ts

@@ -18,6 +18,32 @@ export interface PyricRuntimeChip {
   dispose(): void;
 }
 
+interface AiEngineDisplay {
+  primary: string;
+  subline: string | null;
+}
+
+function aiEngineState(): AiEngineDisplay {
+  const engine = (globalThis as { __PYRIC_AI_ENGINE__?: { kind?: string; model?: string } }).__PYRIC_AI_ENGINE__;
+  if (engine?.kind === 'gemini') {
+    return {
+      primary: 'gemini (production)',
+      subline: 'gemini-3.5-flash-lite → gemini-flash-lite-latest',
+    };
+  }
+  if (engine?.kind === 'openai') {
+    const modelLabel = engine.model ? ` (${engine.model})` : '';
+    return {
+      primary: `openai (proxy${modelLabel})`,
+      subline: null,
+    };
+  }
+  return {
+    primary: 'sandbox (scripted)',
+    subline: null,
+  };
+}
+
 const styles = `
   :host {
     --pyric-bg: #1e1e24;
@@ -86,8 +112,11 @@ const styles = `
   .icon-button[data-copy-failed] { color: var(--pyric-error); }
   .icon { height: 15px; width: 15px; }
   .worker-state { border-top: 1px solid var(--pyric-border-soft); color: var(--pyric-muted); font-size: 10px; justify-content: space-between; min-height: 34px; padding: 7px 12px; }
+  .worker-state-col { border-top: 1px solid var(--pyric-border-soft); color: var(--pyric-muted); font-size: 10px; display: flex; flex-direction: column; min-height: 34px; padding: 7px 12px; }
+  .worker-state-row { align-items: center; display: flex; justify-content: space-between; width: 100%; }
+  .worker-state-subline { color: #89899f; font: 9px/1.4 ui-monospace, monospace; margin-top: 4px; overflow-wrap: anywhere; text-align: right; width: 100%; }
   .worker-state .available { color: var(--pyric-warning); }
-  .worker-state .state-label { align-items: center; display: flex; gap: 7px; }
+  .worker-state .state-label, .worker-state-col .state-label { align-items: center; display: flex; gap: 7px; white-space: nowrap; }
   .mini-dot { background: var(--pyric-accent); border-radius: 50%; height: 6px; width: 6px; }
   .available .mini-dot { background: var(--pyric-warning); }
   .epochs { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
@@ -203,6 +232,7 @@ export function mountPyricRuntimeChip(options: PyricRuntimeChipOptions): PyricRu
     const epochs = snapshot.updateAvailable
       ? `${snapshot.runningEpoch?.slice(0, 8) ?? 'unknown'} → ${snapshot.servedEpoch?.slice(0, 8) ?? 'unknown'}`
       : snapshot.runningEpoch?.slice(0, 8) ?? '';
+    const aiState = aiEngineState();
 
     view.innerHTML = `${open ? `
       <section class="panel" role="dialog" aria-label="Pyric runtime">
@@ -214,6 +244,13 @@ export function mountPyricRuntimeChip(options: PyricRuntimeChipOptions): PyricRu
           </div>
         </header>
         <div class="worker-state"><span class="state-label${snapshot.updateAvailable ? ' available' : ''}"><span class="mini-dot"></span>${workerLabel}</span><span class="epochs">${epochs}</span></div>
+        <div class="worker-state-col" data-ai-status>
+          <div class="worker-state-row">
+            <span class="state-label"><span class="mini-dot"></span>AI engine</span>
+            <span class="epochs">${aiState.primary}</span>
+          </div>
+          ${aiState.subline ? `<div class="worker-state-subline">${aiState.subline}</div>` : ''}
+        </div>
         <div class="errors" data-error-viewport>${renderErrors(snapshot, Boolean(clipboard))}</div>
         <div class="actions">
           <button class="button update" type="button" data-update-worker ${snapshot.updateAvailable ? '' : 'disabled'} aria-disabled="${snapshot.updateAvailable && !snapshot.updatingWorker ? 'false' : 'true'}">${snapshot.updatingWorker ? 'Updating…' : 'Update worker'}</button>