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

package/src/cli/service-commands.generated.ts

@@ -10,6 +10,7 @@ import firestoreRulesResolve from './service-command-records/firestore-rules-res
 import firestoreRulesSimulate from './service-command-records/firestore-rules-simulate.js';
 import firestoreRulesValidate from './service-command-records/firestore-rules-validate.js';
 import storageRulesLint from './service-command-records/storage-rules-lint.js';
+import storageRulesResolve from './service-command-records/storage-rules-resolve.js';
 import storageRulesSimulate from './service-command-records/storage-rules-simulate.js';
 
 export const SERVICE_COMMANDS = [
@@ -23,5 +24,6 @@ export const SERVICE_COMMANDS = [
   { path: ["firestore","rules","simulate"], run: firestoreRulesSimulate },
   { path: ["firestore","rules","validate"], run: firestoreRulesValidate },
   { path: ["storage","rules","lint"], run: storageRulesLint },
+  { path: ["storage","rules","resolve"], run: storageRulesResolve },
   { path: ["storage","rules","simulate"], run: storageRulesSimulate },
 ] as const satisfies readonly ServiceCommand[];

package/src/cli/snapshot.ts

@@ -6,13 +6,13 @@
  *   pyric snapshot [--out FILE] [--port N] [--force] [--json]
  *
  * Source preference:
- *   1. LIVE state from a running `pyric dev --persist`
+ *   1. Live state from a running `pyric sandbox --persist`
  *      (`GET /__pyric/state` — `--port`, else the 3473+ scan window),
  *   2. else the on-disk `.pyric/state/state.json`,
  *   3. else exit 2 with a clear message.
  *
  * The output is a `PyricStateFile` envelope — directly re-servable:
- * `pyric dev --seed <out>` (the state-file shape is detected by its
+ * `pyric sandbox --seed <out>` (the state-file shape is detected by its
  * `version` key and seeds docs + users).
  */
 import { existsSync, writeFileSync } from 'node:fs';
@@ -44,7 +44,7 @@ async function fetchLive(port: number): Promise<LiveState | null> {
     if (!body || typeof body !== 'object' || !('version' in body)) return null;
     return { envelope: body, projectDir: res.headers.get('x-pyric-project-dir') };
   } catch {
-    return null; // nothing listening / not a pyric dev — fall through
+    return null; // No Pyric sandbox is listening. Fall through.
   }
 }
 
@@ -110,7 +110,7 @@ export async function runSnapshot(parsed: ParsedArgs, deps: SnapshotDeps = {}):
   }
   if (!envelope) {
     err.write(
-      'pyric snapshot: no state found — no `pyric dev --persist` is running here and ' +
+      'pyric snapshot: no state found. No `pyric sandbox --persist` is running here and ' +
         'no .pyric/state/state.json exists. Run with --persist (and use the app) first.\n',
     );
     return 2;
@@ -158,7 +158,7 @@ export async function runSnapshot(parsed: ParsedArgs, deps: SnapshotDeps = {}):
   if (redactedCount > 0) {
     report.write(`  ⓘ redacted ${redactedCount} password(s) — re-run with --include-passwords to keep them\n`);
   }
-  report.write(`  Re-serve it: pyric dev --seed ${typeof outFlag === 'string' ? outFlag : 'pyric-state.json'}\n`);
+  report.write(`  Re-serve it: pyric sandbox --seed ${typeof outFlag === 'string' ? outFlag : 'pyric-state.json'}\n`);
   if (json) out.write(JSON.stringify({ out: outPath, docs, users, source, redactedPasswords: redactedCount }) + '\n');
   return 0;
 }

package/src/cli/verify.ts

@@ -108,7 +108,7 @@ export async function runVerify(parsed: ParsedArgs, deps: VerifyCliDeps = {}): P
     } else {
       process.stderr.write(
         `pyric verify: no captured session at ${SERVE_CAPTURE_PATH}.\n` +
-          '  Run `pyric dev`, exercise your app, then `pyric verify`, or pass a fixture path.\n',
+          '  Run `pyric sandbox`, exercise your app, then `pyric verify`, or pass a fixture path.\n',
       );
     }
     return 2;

package/src/functions-rtdb/development-runtime.ts

@@ -6,7 +6,7 @@ import {
   type FunctionsRtdbChildReady,
   type SpawnFunctionsRtdbChildOptions,
 } from './child.js';
-import { buildChildEnv, createLinePrefixer } from '../cli/dev-runner.js';
+import { buildChildEnv, createLinePrefixer } from '../cli/sandbox-runner.js';
 
 const INITIAL_PEER_TIMEOUT_MS = 30_000;
 const RELOAD_PEER_TIMEOUT_MS = 5_000;

package/src/functions-rtdb/project.ts

@@ -22,7 +22,7 @@ export function discoverFunctionsRtdbProject(cwd: string): FunctionsRtdbProject
     config = JSON.parse(readFileSync(firebaseJsonPath, 'utf8')) as FirebaseJson;
   } catch (error) {
     throw new Error(
-      `pyric dev: failed to parse firebase.json while discovering Functions: ` +
+      `pyric sandbox: failed to parse firebase.json while discovering Functions: ` +
         `${error instanceof Error ? error.message : String(error)}`,
     );
   }
@@ -33,23 +33,23 @@ export function discoverFunctionsRtdbProject(cwd: string): FunctionsRtdbProject
     : [config.functions as FunctionsConfig];
   if (declared.length !== 1) {
     throw new Error(
-      'pyric dev: multiple Functions codebases are not supported by the first ' +
+      'pyric sandbox: multiple Functions codebases are not supported by the first ' +
         'onValueCreated slice; configure one source for this development session.',
     );
   }
   const functions = declared[0];
   if (typeof functions !== 'object' || functions === null) {
-    throw new Error('pyric dev: firebase.json `functions` must be an object with a source.');
+    throw new Error('pyric sandbox: firebase.json `functions` must be an object with a source.');
   }
   if (functions.source !== undefined && typeof functions.source !== 'string') {
-    throw new Error('pyric dev: firebase.json `functions.source` must be a string.');
+    throw new Error('pyric sandbox: firebase.json `functions.source` must be a string.');
   }
 
   const sourceDir = resolve(cwd, functions.source ?? 'functions');
   const packageJsonPath = join(sourceDir, 'package.json');
   if (!existsSync(packageJsonPath)) {
     throw new Error(
-      `pyric dev: Functions source is declared but ${packageJsonPath} does not exist.`,
+      `pyric sandbox: Functions source is declared but ${packageJsonPath} does not exist.`,
     );
   }
 
@@ -58,17 +58,17 @@ export function discoverFunctionsRtdbProject(cwd: string): FunctionsRtdbProject
     packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as { main?: unknown };
   } catch (error) {
     throw new Error(
-      `pyric dev: failed to parse ${packageJsonPath}: ` +
+      `pyric sandbox: failed to parse ${packageJsonPath}: ` +
         `${error instanceof Error ? error.message : String(error)}`,
     );
   }
   if (packageJson.main !== undefined && typeof packageJson.main !== 'string') {
-    throw new Error(`pyric dev: ${packageJsonPath} \`main\` must be a string.`);
+    throw new Error(`pyric sandbox: ${packageJsonPath} \`main\` must be a string.`);
   }
 
   const entry = resolve(sourceDir, packageJson.main ?? 'index.js');
   if (!existsSync(entry) || !statSync(entry).isFile()) {
-    throw new Error(`pyric dev: Functions entry does not exist: ${entry}`);
+    throw new Error(`pyric sandbox: Functions entry does not exist: ${entry}`);
   }
   return { sourceDir, entry };
 }

package/src/next/guard.ts

@@ -54,7 +54,7 @@ export function enforceSandboxGuard(options?: PyricNextOptions): void {
   const errorMessage =
     '[Pyric] Next.js development server started without active Pyric sandbox environment variables.\n' +
     'To prevent accidental connections to production Firebase databases, launch this server using:\n' +
-    '  pyric dev -- next dev\n' +
+    '  pyric sandbox -- next dev\n' +
     'or source environment keys via `pyric env`.\n' +
     'To disable this guard, pass { guard: false } to withPyric(config, options).';
   throw new Error(errorMessage);

package/src/remote/index.ts

@@ -5,7 +5,7 @@
  * Server-side Node code (ultimately `pyric-admin`'s remote dispatch arm)
  * reaches the ONE sandbox the app + Studio + agent share:
  *
- *   Node process ──ws──> `pyric dev --bridge` ──ws──> browser tab
+ *   Node process -> `pyric sandbox --bridge` -> browser tab
  *                 (attach/consumer leg)        (peer leg)
  *                                        ──MessagePort──> SharedWorker
  *
@@ -320,7 +320,7 @@ export function createRemoteSandboxCore(
           reject(
             remoteError(
               'deadline-exceeded',
-              `remote sandbox op timed out after ${opTimeoutMs}ms (op: ${payload.method}) — is pyric dev still running?` +
+              `remote sandbox op timed out after ${opTimeoutMs}ms (op: ${payload.method}). Is pyric sandbox still running?` +
                 // A version-skewed old worker accepts frames it cannot
                 // handle and never responds — a timeout is its signature.
                 (versionSkewGuidance ? ` ${versionSkewGuidance}` : ''),
@@ -379,8 +379,8 @@ export function createRemoteSandboxCore(
           msg.serveVersion !== cliVersion()
         ) {
           versionSkewGuidance =
-            `pyric dev is running version ${msg.serveVersion}, this client is ` +
-            `${cliVersion()} — restart pyric dev and reload the browser tab.`;
+            `pyric sandbox is running version ${msg.serveVersion}, this client is ` +
+            `${cliVersion()}. Restart pyric sandbox and reload the browser tab.`;
           process.stderr.write(`pyric: ${versionSkewGuidance}\n`);
         }
         if (msg.peerConnected) readyResolve();
@@ -405,7 +405,7 @@ export function createRemoteSandboxCore(
             // Version skew: a live tab whose SharedWorker predates this op.
             // Other open pages of this origin keep the old worker alive.
             message +=
-              ' — the running sandbox may predate this feature; restart pyric dev ' +
+              '. The running sandbox may predate this feature. Restart pyric sandbox ' +
               'and close other open pages of this origin, then reload.';
           }
           call.reject(remoteError(code, message, msg.error?.denialContext, (msg.error as any)?.envelope));
@@ -721,7 +721,7 @@ export function createRemoteSandboxHandle(opts: {
     enablePersistence: () =>
       throwMember(
         'enablePersistence',
-        'the browser worker owns persistence; it is already enabled by `pyric dev`',
+        'the browser worker owns persistence; it is already enabled by `pyric sandbox`',
       ),
     flush: () =>
       throwMember('flush()', 'the browser worker owns persistence and flushes itself'),
@@ -742,7 +742,7 @@ export function createRemoteSandboxHandle(opts: {
 // ─── connect ───────────────────────────────────────────────────────────────
 
 /**
- * Discover the running `pyric dev --bridge`, attach to its bridge WS as a
+ * Discover the running `pyric sandbox --bridge`, attach to its bridge WS as a
  * worker-relay CONSUMER (never a peer — attaching cannot kick the browser
  * tab out of last-connection-wins), and return the typed remote handle.
  *
@@ -770,7 +770,7 @@ export async function connectRemoteSandbox(
     if (!found) {
       throw remoteError(
         'not-found',
-        'no running `pyric dev --bridge` found (looked for .pyric/serve.json in ' +
+        'no running `pyric sandbox --bridge` found (looked for .pyric/serve.json in ' +
           `${cwd} and the default ports) — start your dev server with the bridge enabled and retry.`,
       );
     }
@@ -953,7 +953,7 @@ export function createLazyRemoteSandbox(
     // Before discovery the URL is unknown; op-level errors always carry the
     // real URL (they come from the inner connect), and `serveUrl` is patched
     // to the discovered value as soon as the first connect succeeds.
-    serveUrl: options.url?.replace(/\/$/, '') ?? '<pyric dev url (pending discovery)>',
+    serveUrl: options.url?.replace(/\/$/, '') ?? '<pyric sandbox url (pending discovery)>',
     close() {
       if (closed) return;
       closed = true;

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;