create-pyric 0.1.0-alpha.11 → 0.1.0-alpha.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-pyric",
-  "version": "0.1.0-alpha.11",
+  "version": "0.1.0-alpha.12",
   "license": "Apache-2.0",
   "homepage": "https://pyric.dev",
   "repository": {
@@ -24,6 +24,7 @@
   },
   "files": [
     "dist",
+    "src",
     "templates",
     "README.md",
     "LICENSE"

package/src/bin.ts

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * `create-pyric` — `npm create pyric [dir]` / `npx create-pyric [dir]`.
+ *
+ * Always scaffolds with registry deps (npm). Default template is `web`
+ * (Vite + `@pyric/cli/vite`).
+ */
+
+import { parseCreateArgs } from './parse-args.js';
+import {
+  applyDepsMode,
+  isTemplateName,
+  normalizeBoolFlags,
+  runScaffold,
+  TEMPLATE_NAMES,
+  TEMPLATES,
+} from './scaffold.js';
+import { readFileSync } from 'node:fs';
+
+function packageVersion(): string {
+  const metadata = JSON.parse(
+    readFileSync(new URL('../package.json', import.meta.url), 'utf8'),
+  ) as { version?: unknown };
+  if (typeof metadata.version !== 'string' || metadata.version.length === 0) {
+    throw new Error('create-pyric package metadata has no version');
+  }
+  return metadata.version;
+}
+
+async function main(): Promise<number> {
+  const args = parseCreateArgs(process.argv.slice(2));
+  normalizeBoolFlags(args.flags, args.positional);
+
+  if (args.flags.get('help') === true || args.flags.get('h') === true) {
+    process.stdout.write(
+      `Usage: npm create pyric [dir] [--template ${TEMPLATE_NAMES.join('|')}] [--name N] [--force] [--json]\n` +
+        `       npx create-pyric [dir] [flags]\n\n` +
+        `Default template is web (Vite + @pyric/cli/vite).\n` +
+        `Directory: optional positional; omit to scaffold in the current directory.\n`,
+    );
+    return 0;
+  }
+
+  const templateFlag = args.flags.get('template');
+  const templateName = typeof templateFlag === 'string' ? templateFlag : 'web';
+  if (!isTemplateName(templateName)) {
+    process.stderr.write(
+      `create-pyric: unknown template '${templateName}' (expected ${TEMPLATE_NAMES.join('|')})\n`,
+    );
+    return 1;
+  }
+
+  const nameFlag = args.flags.get('name');
+  const name = typeof nameFlag === 'string' && nameFlag.length > 0 ? nameFlag : undefined;
+
+  const version = packageVersion();
+  const effectiveTemplate = applyDepsMode(TEMPLATES[templateName], 'npm', { version });
+
+  return runScaffold(
+    {
+      dir: args.positional[0],
+      template: templateName,
+      name,
+      force: args.flags.get('force') === true,
+      json: args.flags.get('json') === true,
+      depsMode: 'npm',
+      effectiveTemplate,
+      pinVersion: version,
+      commandLabel: 'create-pyric',
+    },
+  );
+}
+
+const code = await main();
+process.exit(code);

package/src/index.ts

@@ -0,0 +1,22 @@
+/**
+ * `create-pyric` — scaffold engine for `npm create pyric` and `pyric init`.
+ */
+
+export {
+  TEMPLATES,
+  TEMPLATE_NAMES,
+  isTemplateName,
+  applyDepsMode,
+  mergeIntoExistingPackageJson,
+  packageJsonFor,
+  normalizeBoolFlags,
+  runScaffold,
+  type ScaffoldTemplate,
+  type DepsMode,
+  type ScaffoldResult,
+  type ScaffoldRequest,
+  type ScaffoldIo,
+  type PackageJsonMerge,
+  type TemplateName,
+} from './scaffold.js';
+export { parseCreateArgs, type CreateArgs, type FlagValue } from './parse-args.js';

package/src/parse-args.ts

@@ -0,0 +1,60 @@
+/**
+ * Minimal argv parser for `create-pyric` (no subcommand — first bare
+ * arg is the target directory).
+ */
+
+export type FlagValue = string | boolean | Array<string | boolean>;
+
+export interface CreateArgs {
+  flags: Map<string, FlagValue>;
+  positional: string[];
+}
+
+export function parseCreateArgs(argv: string[]): CreateArgs {
+  const flags = new Map<string, FlagValue>();
+  const positional: string[] = [];
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === undefined) {
+      i += 1;
+      continue;
+    }
+    if (arg === '--') {
+      // Flags after `--` are still ours (npm create pyric dir -- --force).
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--')) {
+      const eq = arg.indexOf('=');
+      if (eq !== -1) {
+        setFlag(flags, arg.slice(2, eq), arg.slice(eq + 1));
+      } else {
+        const next = argv[i + 1];
+        if (next && !next.startsWith('-')) {
+          setFlag(flags, arg.slice(2), next);
+          i += 1;
+        } else {
+          setFlag(flags, arg.slice(2), true);
+        }
+      }
+    } else if (arg.startsWith('-')) {
+      setFlag(flags, arg.slice(1), true);
+    } else {
+      positional.push(arg);
+    }
+    i += 1;
+  }
+  return { flags, positional };
+}
+
+function setFlag(flags: Map<string, FlagValue>, key: string, value: string | boolean): void {
+  const current = flags.get(key);
+  if (current === undefined) {
+    flags.set(key, value);
+  } else if (Array.isArray(current)) {
+    current.push(value);
+  } else {
+    flags.set(key, [current, value]);
+  }
+}

package/src/scaffold.ts

@@ -0,0 +1,356 @@
+/**
+ * Shared project scaffold used by `create-pyric` and `pyric init`.
+ *
+ * Never prompts. Idempotent: existing files are merged (package.json) or
+ * skipped; `--force` overwrites scaffold-owned files only.
+ */
+
+import { writeFile, readFile, mkdir, access } from 'node:fs/promises';
+import { join, basename, resolve } from 'node:path';
+import {
+  TEMPLATES,
+  TEMPLATE_NAMES,
+  isTemplateName,
+  type ScaffoldTemplate,
+  type TemplateName,
+} from './templates.js';
+import type { FlagValue } from './parse-args.js';
+
+export type { ScaffoldTemplate, TemplateName };
+export { TEMPLATES, TEMPLATE_NAMES, isTemplateName } from './templates.js';
+
+/** Where the scaffold's `pyric` / `@pyric/cli` deps come from. */
+export type DepsMode = 'vendor' | 'npm';
+
+/** Return a copy of `t` with `pyric` / `@pyric/cli` deps rewritten for `mode`. */
+export function applyDepsMode(
+  t: ScaffoldTemplate,
+  mode: DepsMode,
+  opts: { vendorSpecs?: Record<string, string>; version?: string | null },
+): ScaffoldTemplate {
+  const WORKSPACE_PKGS = ['pyric', '@pyric/cli'];
+  const rewrite = (section: Record<string, string>): Record<string, string> => {
+    const next = { ...section };
+    for (const pkg of WORKSPACE_PKGS) {
+      if (!(pkg in next)) continue;
+      next[pkg] =
+        mode === 'vendor'
+          ? (opts.vendorSpecs?.[pkg] ?? next[pkg])
+          : opts.version
+            ? `^${opts.version}`
+            : next[pkg];
+    }
+    if (mode === 'vendor' && '@pyric/cli' in next && !('pyric' in next) && opts.vendorSpecs?.pyric) {
+      next.pyric = opts.vendorSpecs.pyric;
+    }
+    return next;
+  };
+  // Vendor mode pins EVERY vendored package via overrides (not just direct
+  // deps): @pyric/cli's packed manifest depends on pyric / pyric-admin /
+  // create-pyric as version ranges (workspace:* is rewritten at pack time),
+  // and those names are unpublished — only an override to the local tarball
+  // lets the install resolve them offline. @pyric/cli itself is always a
+  // direct dep with a file: spec, so it needs no override.
+  const vendorOverrides =
+    mode === 'vendor' && opts.vendorSpecs
+      ? Object.fromEntries(Object.entries(opts.vendorSpecs).filter(([pkg]) => pkg !== '@pyric/cli'))
+      : undefined;
+  const overrides =
+    vendorOverrides && Object.keys(vendorOverrides).length > 0 ? vendorOverrides : t.overrides;
+  return {
+    ...t,
+    dependencies: rewrite(t.dependencies),
+    devDependencies: rewrite(t.devDependencies),
+    overrides,
+  };
+}
+
+export interface PackageJsonMerge {
+  contents: string;
+  added: string[];
+  conflicts: Array<{ key: string; existing: unknown; wanted: unknown }>;
+  unchanged: boolean;
+}
+
+function detectIndent(raw: string): string | number {
+  const m = raw.match(/\n([ \t]+)"/);
+  if (!m) return 2;
+  const ws = m[1]!;
+  return ws.includes('\t') ? '\t' : ws.length;
+}
+
+/** Merge template fields into an existing package.json. Never overwrites. */
+export function mergeIntoExistingPackageJson(
+  raw: string,
+  projectName: string,
+  template: ScaffoldTemplate,
+): PackageJsonMerge {
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `package.json is not valid JSON: ${e instanceof Error ? e.message : String(e)}`,
+    );
+  }
+  const indent = detectIndent(raw);
+  const added: string[] = [];
+  const conflicts: PackageJsonMerge['conflicts'] = [];
+
+  if (parsed.name === undefined) {
+    parsed.name = projectName;
+    added.push('name');
+  }
+  if (parsed.type === undefined) {
+    parsed.type = 'module';
+    added.push('type');
+  } else if (parsed.type !== 'module') {
+    conflicts.push({ key: 'type', existing: parsed.type, wanted: 'module' });
+  }
+  if (parsed.private === undefined) {
+    parsed.private = true;
+    added.push('private');
+  }
+
+  const mergeObject = (
+    field: 'scripts' | 'dependencies' | 'devDependencies' | 'overrides',
+    wanted: Record<string, string>,
+  ) => {
+    if (parsed[field] === undefined) {
+      parsed[field] = {};
+    }
+    const obj = parsed[field] as Record<string, unknown>;
+    for (const [key, value] of Object.entries(wanted)) {
+      if (obj[key] === undefined) {
+        obj[key] = value;
+        added.push(`${field}.${key}`);
+      } else if (obj[key] !== value) {
+        conflicts.push({ key: `${field}.${key}`, existing: obj[key], wanted: value });
+      }
+    }
+  };
+  mergeObject('scripts', template.scripts);
+  mergeObject('dependencies', template.dependencies);
+  mergeObject('devDependencies', template.devDependencies);
+  if (template.overrides) mergeObject('overrides', template.overrides);
+
+  return {
+    contents: JSON.stringify(parsed, null, indent) + '\n',
+    added,
+    conflicts,
+    unchanged: added.length === 0 && conflicts.length === 0,
+  };
+}
+
+export function packageJsonFor(name: string, t: ScaffoldTemplate): string {
+  return (
+    JSON.stringify(
+      {
+        name,
+        version: '0.0.0',
+        type: 'module',
+        private: true,
+        scripts: t.scripts,
+        dependencies: t.dependencies,
+        devDependencies: t.devDependencies,
+        ...(t.overrides ? { overrides: t.overrides } : {}),
+      },
+      null,
+      2,
+    ) + '\n'
+  );
+}
+
+/** Stable `--json` contract; agents parse this. */
+export interface ScaffoldResult {
+  template: TemplateName;
+  dir: string;
+  depsMode: DepsMode;
+  created: string[];
+  merged: string[];
+  skipped: string[];
+  conflicts: Array<{ key: string; existing: unknown; wanted: unknown }>;
+  nextSteps: string[];
+}
+
+export interface ScaffoldIo {
+  writeFile?: typeof writeFile;
+  readFile?: typeof readFile;
+  mkdir?: typeof mkdir;
+  exists?: (path: string) => Promise<boolean>;
+  cwd?: string;
+  stdout?: { write(s: string): void };
+  stderr?: { write(s: string): void };
+}
+
+async function defaultExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export interface ScaffoldRequest {
+  /** Absolute or relative project directory (relative resolved against cwd). */
+  dir?: string;
+  template?: TemplateName;
+  name?: string;
+  force?: boolean;
+  json?: boolean;
+  depsMode?: DepsMode;
+  /** Already-rewritten template; defaults to TEMPLATES[template] (+ npm pin). */
+  effectiveTemplate?: ScaffoldTemplate;
+  /** Version pin for npm-mode `@pyric/cli` / `pyric` ranges. */
+  pinVersion?: string | null;
+  /** Label used in human report lines (`create-pyric` or `pyric init`). */
+  commandLabel?: string;
+  /** Extra paths already created (e.g. vendor tarballs) to list in the report. */
+  preCreated?: string[];
+}
+
+/** Reclaim `--force dir` / `--json dir` when a parser bound the value as the flag. */
+export function normalizeBoolFlags(flags: Map<string, FlagValue>, positional: string[]): void {
+  for (const key of ['force', 'json']) {
+    const v = flags.get(key);
+    if (typeof v === 'string') {
+      positional.push(v);
+      flags.set(key, true);
+    }
+  }
+}
+
+/**
+ * Write the scaffold into `dir`. Caller prepares vendor tarballs / pin when
+ * needed and may pass `effectiveTemplate`.
+ */
+export async function runScaffold(
+  request: ScaffoldRequest,
+  deps: ScaffoldIo = {},
+): Promise<number> {
+  const out = deps.stdout ?? process.stdout;
+  const err = deps.stderr ?? process.stderr;
+  const cwd = deps.cwd ?? process.cwd();
+  const write = deps.writeFile ?? writeFile;
+  const read = deps.readFile ?? readFile;
+  const mk = deps.mkdir ?? mkdir;
+  const exists = deps.exists ?? defaultExists;
+  const label = request.commandLabel ?? 'create-pyric';
+
+  const templateName = request.template ?? 'web';
+  if (!isTemplateName(templateName)) {
+    err.write(
+      `${label}: unknown template '${templateName}' (expected ${TEMPLATE_NAMES.join('|')})\n`,
+    );
+    return 1;
+  }
+  const template = TEMPLATES[templateName];
+  const depsMode: DepsMode = request.depsMode ?? 'npm';
+  const pinVersion = request.pinVersion ?? null;
+
+  const dir = request.dir ? resolve(cwd, request.dir) : cwd;
+  const projectName =
+    request.name && request.name.length > 0 ? request.name : basename(dir);
+  const force = request.force === true;
+  const json = request.json === true;
+  const report = json ? err : out;
+
+  try {
+    for (const d of [dir, ...template.dirs.map((d) => join(dir, d))]) {
+      await mk(d, { recursive: true });
+    }
+  } catch (e) {
+    err.write(
+      `${label}: failed to create project directories: ${e instanceof Error ? e.message : String(e)}\n`,
+    );
+    return 2;
+  }
+
+  const effective =
+    request.effectiveTemplate ??
+    applyDepsMode(template, depsMode === 'vendor' ? 'vendor' : 'npm', {
+      version: pinVersion,
+    });
+
+  const result: ScaffoldResult = {
+    template: templateName,
+    dir,
+    depsMode,
+    created: [...(request.preCreated ?? [])],
+    merged: [],
+    skipped: [],
+    conflicts: [],
+    nextSteps: template.nextSteps,
+  };
+
+  const pkgPath = join(dir, 'package.json');
+  let pkgMerge: PackageJsonMerge | null = null;
+  try {
+    if (await exists(pkgPath)) {
+      const raw = (await read(pkgPath, 'utf-8')) as unknown;
+      const text = typeof raw === 'string' ? raw : String(raw);
+      pkgMerge = mergeIntoExistingPackageJson(text, projectName, effective);
+      result.conflicts = pkgMerge.conflicts;
+      if (pkgMerge.unchanged) {
+        result.skipped.push('package.json');
+      } else {
+        await write(pkgPath, pkgMerge.contents, 'utf-8');
+        result.merged.push('package.json');
+      }
+    } else {
+      await write(pkgPath, packageJsonFor(projectName, effective), 'utf-8');
+      result.created.push('package.json');
+    }
+  } catch (e) {
+    err.write(
+      `${label}: failed to handle package.json: ${e instanceof Error ? e.message : String(e)}\n`,
+    );
+    return 2;
+  }
+
+  for (const t of template.files(projectName)) {
+    const path = join(dir, t.name);
+    if (!force && (await exists(path))) {
+      result.skipped.push(t.name);
+      continue;
+    }
+    try {
+      await write(path, t.content, 'utf-8');
+      result.created.push(t.name);
+    } catch (e) {
+      err.write(
+        `${label}: failed to write ${t.name}: ${e instanceof Error ? e.message : String(e)}\n`,
+      );
+      return 2;
+    }
+  }
+
+  report.write(`${label}: scaffolded ${templateName} project "${projectName}" in ${dir}\n`);
+  for (const c of result.created) report.write(`  + wrote ${c}\n`);
+  for (const m of result.merged) {
+    report.write(`  ~ merged ${m} (added: ${pkgMerge!.added.join(', ')})\n`);
+  }
+  for (const s of result.skipped) report.write(`  · skipped ${s} (already exists)\n`);
+
+  if (result.conflicts.length > 0) {
+    report.write('\npackage.json — kept your values for these keys (pyric wanted different):\n');
+    for (const c of result.conflicts) {
+      report.write(
+        `  · ${c.key}: ${JSON.stringify(c.existing)}  (pyric would have set ${JSON.stringify(c.wanted)})\n`,
+      );
+    }
+  }
+
+  report.write(
+    depsMode === 'vendor'
+      ? '\n  deps: vendored pyric + @pyric/cli into vendor/ — installs offline, no registry\n'
+      : `\n  deps: pyric + @pyric/cli from npm${pinVersion ? ` (^${pinVersion})` : ''}\n`,
+  );
+
+  report.write('\nNext steps:\n');
+  for (const s of result.nextSteps) report.write(`  ${s}\n`);
+
+  if (json) out.write(JSON.stringify(result) + '\n');
+  return 0;
+}

package/src/templates.ts

@@ -0,0 +1,795 @@
+/**
+ * Scaffold templates for `pyric init` (engine in `./init.js`).
+ *
+ * `web` (the default) scaffolds a **Vite app** wired to the `@pyric/cli/vite`
+ * plugin: `vite dev` runs the app's CANONICAL `firebase/*` imports against the
+ * in-process sandbox; `vite build` ships the real `firebase` package. One
+ * toolchain, no graduation cliff — the sandbox↔Firebase swap is environmental
+ * (dev vs build), never a code edit (the design rationale section 9).
+ *
+ * `static` is the serve-era scaffold (no bundler): a static app `pyric dev`
+ * runs against the in-page sandbox via a runtime import map. For pre-built /
+ * retrofit apps, or anyone who wants zero build step.
+ *
+ * `node` is the script-style scaffold (backend fixtures, agent loops). Its
+ * canonical imports are swapped by the dev command and remain Firebase under
+ * the production command.
+ */
+
+import { lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, dirname, isAbsolute, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+export const TEMPLATE_NAMES = ['web', 'node', 'static', 'chat'] as const;
+export type TemplateName = (typeof TEMPLATE_NAMES)[number];
+
+export function isTemplateName(value: string): value is TemplateName {
+  return (TEMPLATE_NAMES as readonly string[]).includes(value);
+}
+
+export interface ScaffoldTemplate {
+  /** package.json pieces merged into existing files / written into new ones. */
+  scripts: Record<string, string>;
+  dependencies: Record<string, string>;
+  devDependencies: Record<string, string>;
+  /** npm/bun `overrides` (optional). Vendor mode sets `{ pyric: file:… }` so a
+   *  transitive `pyric` dep can't resolve to the published placeholder. */
+  overrides?: Record<string, string>;
+  /** Directories created before writing files (relative to the project dir). */
+  dirs: string[];
+  /** Scaffold-owned files, relative path → content. */
+  files(name: string): Array<{ name: string; content: string }>;
+  /** Literal commands for the report / `--json` consumers. */
+  nextSteps: string[];
+}
+
+interface AssetManifest {
+  include: string[];
+}
+
+interface AssetFile {
+  name: string;
+  content: string;
+}
+
+const ASSET_IGNORES = new Set([
+  '.agents',
+  '.codex',
+  '.env',
+  '.env.local',
+  '.git',
+  '.pyric',
+  'bun.lock',
+  'dist',
+  'node_modules',
+  'package-lock.json',
+  'pnpm-lock.yaml',
+  'test-results',
+  'yarn.lock',
+]);
+
+/** Load one allowlisted packaged tree; the runnable tree is the scaffold source. */
+export function loadAssetTemplate(templateName: string, templateRoot?: string): {
+  packageJson: {
+    scripts: Record<string, string>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    overrides?: Record<string, string>;
+  };
+  dirs: string[];
+  files: AssetFile[];
+} {
+  const root = resolve(
+    templateRoot ?? fileURLToPath(new URL(`../templates/${templateName}/`, import.meta.url)),
+  );
+  const manifest = JSON.parse(readFileSync(resolve(root, 'scaffold.json'), 'utf8')) as AssetManifest;
+  const packageJson = JSON.parse(readFileSync(resolve(root, 'package.json'), 'utf8')) as {
+    scripts: Record<string, string>;
+    dependencies: Record<string, string>;
+    devDependencies: Record<string, string>;
+    overrides?: Record<string, string>;
+  };
+  if (!Array.isArray(manifest.include) || manifest.include.length === 0) {
+    throw new Error(`create-pyric: template '${templateName}' has no scaffold include list`);
+  }
+
+  const files: AssetFile[] = [];
+  const seenFiles = new Set<string>();
+  const dirs = new Set<string>();
+  const walk = (absolute: string): void => {
+    if (ASSET_IGNORES.has(basename(absolute))) return;
+    const stat = lstatSync(absolute);
+    if (stat.isSymbolicLink()) {
+      throw new Error(`create-pyric: template '${templateName}' contains a symlink: ${absolute}`);
+    }
+    if (stat.isDirectory()) {
+      for (const entry of readdirSync(absolute).sort()) walk(resolve(absolute, entry));
+      return;
+    }
+    if (!stat.isFile()) {
+      throw new Error(
+        `create-pyric: template '${templateName}' contains a non-file asset: ${absolute}`,
+      );
+    }
+    const rawRelative = relative(root, absolute).split(sep).join('/');
+    const name = rawRelative === 'gitignore' ? '.gitignore' : rawRelative;
+    if (seenFiles.has(name)) {
+      throw new Error(`create-pyric: template '${templateName}' includes '${name}' more than once`);
+    }
+    seenFiles.add(name);
+    const bytes = readFileSync(absolute);
+    if (bytes.includes(0)) {
+      throw new Error(
+        `create-pyric: template '${templateName}' contains a binary asset: ${rawRelative}`,
+      );
+    }
+    let parent = dirname(name).split(sep).join('/');
+    while (parent !== '.') {
+      dirs.add(parent);
+      parent = dirname(parent).split(sep).join('/');
+    }
+    files.push({ name, content: bytes.toString('utf8') });
+  };
+
+  for (const entry of manifest.include) {
+    if (!entry || isAbsolute(entry) || entry.split(/[\\/]/).includes('..')) {
+      throw new Error(`create-pyric: template '${templateName}' has unsafe include '${entry}'`);
+    }
+    const absolute = resolve(root, entry);
+    if (absolute !== root && !absolute.startsWith(root + sep)) {
+      throw new Error(`create-pyric: template '${templateName}' include escapes its root: '${entry}'`);
+    }
+    walk(absolute);
+  }
+
+  files.sort((a, b) => a.name.localeCompare(b.name));
+  return { packageJson, dirs: [...dirs].sort(), files };
+}
+
+// ─── web template ─────────────────────────────────────────────────────
+
+const WEB_INDEX_HTML = (name: string): string => `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${name}</title>
+    <style>
+      body { font: 16px/1.5 system-ui, sans-serif; max-width: 640px; margin: 3rem auto; padding: 0 1rem; }
+      button { padding: 0.4rem 0.9rem; cursor: pointer; }
+      form { display: flex; gap: 0.5rem; margin: 1rem 0; }
+      input { flex: 1; padding: 0.4rem 0.6rem; }
+      ul { padding-left: 1.2rem; }
+      .status { color: #666; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${name}</h1>
+      <p class="status" id="auth-status">Signed out</p>
+      <button id="sign-in">Sign in with Google</button>
+      <button id="sign-out" hidden>Sign out</button>
+      <form id="add-post" hidden>
+        <input id="post-title" placeholder="Post title" required />
+        <button type="submit">Add post</button>
+      </form>
+      <ul id="posts"></ul>
+    </main>
+    <script type="module" src="/app.js"></script>
+  </body>
+</html>
+`;
+
+const WEB_APP_JS = `// Canonical firebase/* imports. Under \`pyric dev\` they are served by the
+// in-page pyric sandbox (the config below is ignored); under any standard
+// bundler/pipeline the same imports resolve to the real \`firebase\` package.
+// Graduation changes where you run this code, never the code itself.
+import { initializeApp } from 'firebase/app';
+import {
+  getAuth,
+  onAuthStateChanged,
+  signInWithPopup,
+  signOut,
+  GoogleAuthProvider,
+} from 'firebase/auth';
+import {
+  getFirestore,
+  collection,
+  onSnapshot,
+  addDoc,
+  serverTimestamp,
+} from 'firebase/firestore';
+
+const app = initializeApp({
+  // Graduation: your real web-app config from the Firebase console
+  // (see .env.example). Unused while developing under \`pyric dev\`.
+  apiKey: 'demo',
+  authDomain: 'demo.firebaseapp.com',
+  projectId: 'demo',
+});
+const auth = getAuth(app);
+const db = getFirestore(app);
+
+const els = {
+  status: document.getElementById('auth-status'),
+  signIn: document.getElementById('sign-in'),
+  signOut: document.getElementById('sign-out'),
+  form: document.getElementById('add-post'),
+  title: document.getElementById('post-title'),
+  posts: document.getElementById('posts'),
+};
+
+els.signIn.addEventListener('click', () => signInWithPopup(auth, new GoogleAuthProvider()));
+els.signOut.addEventListener('click', () => signOut(auth));
+
+onAuthStateChanged(auth, (user) => {
+  els.status.textContent = user
+    ? 'Signed in as ' + (user.displayName ?? user.email)
+    : 'Signed out';
+  els.signIn.hidden = !!user;
+  els.signOut.hidden = !user;
+  els.form.hidden = !user;
+});
+
+els.form.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  // The owner-based rules require uid == request.auth.uid on create.
+  await addDoc(collection(db, 'posts'), {
+    title: els.title.value.trim(),
+    uid: auth.currentUser.uid,
+    createdAt: serverTimestamp(),
+  });
+  els.title.value = '';
+});
+
+onSnapshot(collection(db, 'posts'), (snap) => {
+  els.posts.replaceChildren(
+    ...snap.docs.map((d) => {
+      const li = document.createElement('li');
+      li.textContent = d.data().title;
+      return li;
+    }),
+  );
+});
+`;
+
+const WEB_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Owner-based from line 1 — \`pyric dev\` hot-reloads this file and
+    // ships a sign-in helper, so safe rules are cheap to iterate. These
+    // deploy as-is.
+    match /posts/{postId} {
+      allow read: if true;
+      allow create: if request.auth != null
+                    && request.resource.data.uid == request.auth.uid;
+      allow update, delete: if request.auth != null
+                            && resource.data.uid == request.auth.uid;
+    }
+
+    // Default deny — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+
+const WEB_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "hosting": {
+    "public": "public",
+    "rewrites": [{ "source": "**", "destination": "/index.html" }]
+  }
+}
+`;
+
+const WEB_SEED_JSON = `{
+  "posts/welcome": { "title": "Welcome to pyric", "uid": "seed" },
+  "posts/sandboxed": { "title": "This page runs on the in-page sandbox", "uid": "seed" }
+}
+`;
+
+const WEB_ENV_EXAMPLE = `# Graduation config — your real Firebase web app (console → project settings).
+# Unused under \`pyric dev\`; wire it into public/app.js (or a bundler env)
+# when you deploy against the real backend.
+FIREBASE_API_KEY=
+FIREBASE_AUTH_DOMAIN=
+FIREBASE_PROJECT_ID=
+FIREBASE_STORAGE_BUCKET=
+FIREBASE_MESSAGING_SENDER_ID=
+FIREBASE_APP_ID=
+`;
+
+const webReadme = (name: string): string => `# ${name}
+
+A Firebase web app. In development it runs entirely on pyric's in-page
+sandbox — no Firebase project, credentials, or emulators.
+
+- **Develop:** \`bun install && bun run dev\` — serves \`public/\` with the
+  sandbox standing in for Firebase: seeded data, rules enforced + hot-reloaded,
+  popup sign-in via the helper dialog.
+- **Agent:** \`bun run dev:agent\` — same, plus the MCP bridge on the dev-server
+  origin (\`/__pyric/mcp\`).
+- **Persist (optional):** \`pyric dev --persist --seed seed.json\` — data and
+  test users survive reloads and restarts in \`.pyric/state/state.json\`
+  (plain JSON; gitignored). Promote lived state to a committable fixture
+  with \`pyric snapshot\`, then re-serve it: \`pyric dev --seed pyric-state.json\`.
+- **Graduate:** fill \`.env\` from the Firebase console and point the config in
+  \`public/app.js\` at it, then run \`npx firebase-tools deploy\`. Bare
+  \`firebase/*\` imports need a bundler
+  (e.g. \`vite build\`) or an import map in production — \`pyric dev\`
+  provides the map in dev.
+
+The app code uses canonical \`firebase/*\` imports everywhere. Switching
+between sandbox and real Firebase is about **where you run it**, never what
+you wrote.
+`;
+
+const GITIGNORE = `node_modules/
+dist/
+.env
+.firebaserc
+.pyric/
+*.log
+`;
+
+const FIRESTORE_INDEXES = `{
+  "indexes": [],
+  "fieldOverrides": []
+}
+`;
+
+// ─── node template (init v1 scaffold, carried over) ───────────────────
+
+const NODE_APP_TS = `// Canonical Firebase imports stay unchanged between sandbox and production.
+// \`bun run dev\` activates @pyric/cli/register; \`bun start\` loads Firebase.
+import { initializeApp } from 'firebase/app';
+import { getFirestore, collection, getDocs } from 'firebase/firestore';
+import { seed } from './seed.ts';
+
+const app = initializeApp({
+  apiKey: process.env.FIREBASE_API_KEY ?? 'pyric-local',
+  authDomain: process.env.FIREBASE_AUTH_DOMAIN,
+  projectId: process.env.FIREBASE_PROJECT_ID ?? 'pyric-local',
+  appId: process.env.FIREBASE_APP_ID ?? 'pyric-local',
+});
+const db = getFirestore(app);
+
+if (process.env.PYRIC_SANDBOX) {
+  await seed(db);
+}
+
+const snap = await getDocs(collection(db, 'posts'));
+console.log(\`\${snap.size} posts:\`);
+snap.forEach((doc) => console.log(\`  \${doc.id}:\`, doc.data()));
+
+// Production: fill .env, deploy firestore.rules, then \`bun start\`.
+`;
+
+const NODE_SEED_TS = `import { collection, addDoc, type Firestore } from 'firebase/firestore';
+
+export async function seed(db: Firestore): Promise<void> {
+  await addDoc(collection(db, 'posts'), {
+    title: 'Hello, Pyric',
+    author: 'sandbox',
+    createdAt: new Date(),
+  });
+  await addDoc(collection(db, 'posts'), {
+    title: 'Local-first by default',
+    author: 'sandbox',
+    createdAt: new Date(),
+  });
+}
+`;
+
+const NODE_ENV_EXAMPLE = `# Production Firebase config (Firebase console -> project settings).
+# Sandbox development uses the fallback values in src/app.ts.
+FIREBASE_API_KEY=
+FIREBASE_AUTH_DOMAIN=
+FIREBASE_PROJECT_ID=
+FIREBASE_APP_ID=
+`;
+
+const NODE_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Local-first defaults: open in the sandbox so the quickstart
+    // works out of the box. **Tighten these before deploying with firebase-tools**
+    // — anonymous read+write is not what you want
+    // in the wild.
+    match /posts/{postId} {
+      allow read: if true;
+      allow write: if true;
+    }
+
+    // Default deny for everything else — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+
+const NODE_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  }
+}
+`;
+
+const nodeReadme = (name: string): string => `# ${name}
+
+A Firebase app whose canonical imports run against Pyric in development and
+real Firebase in production. No application-code switch is required.
+
+## Quick start
+
+\`\`\`bash
+bun install
+bun run dev        # Pyric sandbox through the Node package swap
+bun start          # production: real Firebase
+\`\`\`
+
+## Use with an MCP-connected agent (Claude Code)
+
+Install the pyric Claude Code plugin once. It auto-connects through a bundled
+stdio proxy that discovers the running bridge from \`.pyric/serve.json\` and probes
+both IPv4 + IPv6, so there is NO \`claude mcp add\` step and no hand-written URL (a
+static \`127.0.0.1\` URL hits the loopback-family trap). Just start the bridge:
+
+\`\`\`bash
+pyric bridge       # default port 5174
+\`\`\`
+
+and the agent's pyric tools attach automatically.
+
+## Graduating to a real Firebase project
+
+Graduation is a command change, not a code edit:
+
+1. Create a project at https://console.firebase.google.com and fill \`.env\`
+   (see \`.env.example\`).
+2. **Tighten \`firestore.rules\`** — the scaffolded rules are open for
+   sandbox convenience.
+3. Deploy them with the Firebase CLI: add a \`.firebaserc\`
+   (\`{ "projects": { "default": "your-project-id" } }\`), then run
+   \`npx firebase-tools deploy --only firestore:rules\`.
+4. Run the same canonical-import code against the real backend: \`bun start\`.
+`;
+
+// ─── web template (Vite + @pyric/cli/vite) ───────────────────────────
+
+const VITE_INDEX_HTML = (name: string): string => `<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${name}</title>
+    <style>
+      body { font: 16px/1.5 system-ui, sans-serif; max-width: 640px; margin: 3rem auto; padding: 0 1rem; }
+      button { padding: 0.4rem 0.9rem; cursor: pointer; }
+      form { display: flex; gap: 0.5rem; margin: 1rem 0; }
+      input { flex: 1; padding: 0.4rem 0.6rem; }
+      ul { padding-left: 1.2rem; }
+      .status { color: #666; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>${name}</h1>
+      <p class="status" id="auth-status">Signed out</p>
+      <button id="sign-in">Sign in with Google</button>
+      <button id="sign-out" hidden>Sign out</button>
+      <!-- Visible even while signed out ON PURPOSE — submitting attempts the
+           write and the owner-based rules deny it (see src/main.ts). -->
+      <form id="add-post">
+        <input id="post-title" placeholder="Post title" required />
+        <button type="submit">Add post</button>
+      </form>
+      <ul id="posts"></ul>
+    </main>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`;
+
+const VITE_MAIN_TS = `// Canonical firebase/* imports — UNCHANGED between dev and prod.
+// In \`vite dev\` the \`@pyric/cli/vite\` plugin swaps these to an in-process
+// sandbox (the config below is accepted but ignored). \`vite build\` ships the
+// real \`firebase\` package and uses the SAME config. Graduation is a build, not
+// a code edit.
+import { initializeApp } from 'firebase/app';
+import {
+  getAuth,
+  onAuthStateChanged,
+  signInWithPopup,
+  signOut,
+  GoogleAuthProvider,
+} from 'firebase/auth';
+import {
+  getFirestore,
+  collection,
+  onSnapshot,
+  addDoc,
+  serverTimestamp,
+} from 'firebase/firestore';
+
+const app = initializeApp({
+  // Filled from .env (see .env.example) at \`vite build\` time for production.
+  // Ignored in \`vite dev\` — the pyric sandbox stands in for Firebase.
+  apiKey: import.meta.env.VITE_FIREBASE_API_KEY ?? 'demo',
+  authDomain: import.meta.env.VITE_FIREBASE_AUTH_DOMAIN ?? 'demo.firebaseapp.com',
+  projectId: import.meta.env.VITE_FIREBASE_PROJECT_ID ?? 'demo',
+});
+const auth = getAuth(app);
+const db = getFirestore(app);
+
+const $ = <T extends HTMLElement>(id: string): T => document.getElementById(id) as T;
+const els = {
+  status: $('auth-status'),
+  signIn: $<HTMLButtonElement>('sign-in'),
+  signOut: $<HTMLButtonElement>('sign-out'),
+  form: $<HTMLFormElement>('add-post'),
+  title: $<HTMLInputElement>('post-title'),
+  posts: $('posts'),
+};
+
+els.signIn.addEventListener('click', () => signInWithPopup(auth, new GoogleAuthProvider()));
+els.signOut.addEventListener('click', () => signOut(auth));
+
+onAuthStateChanged(auth, (user) => {
+  els.status.textContent = user
+    ? 'Signed in as ' + (user.displayName ?? user.email)
+    : 'Signed out';
+  els.signIn.hidden = !!user;
+  els.signOut.hidden = !user;
+});
+
+els.form.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  // The form stays visible while signed out ON PURPOSE: submitting then
+  // ATTEMPTS the write, the owner-based rules deny it (create requires
+  // uid == request.auth.uid), and the denial shows up in Pyric Studio's
+  // Traffic tab — the rules-teaching loop this demo exists for.
+  const user = auth.currentUser;
+  try {
+    await addDoc(collection(db, 'posts'), {
+      title: els.title.value.trim(),
+      uid: user?.uid ?? 'anonymous',
+      createdAt: serverTimestamp(),
+    });
+    els.title.value = '';
+  } catch (err) {
+    els.status.textContent = user
+      ? \`Write failed: \${(err as { code?: string }).code ?? String(err)}\`
+      : 'Denied by rules (signed out) — see the Traffic tab in Pyric Studio.';
+  }
+});
+
+onSnapshot(collection(db, 'posts'), (snap) => {
+  els.posts.replaceChildren(
+    ...snap.docs.map((d) => {
+      const li = document.createElement('li');
+      li.textContent = (d.data() as { title?: string }).title ?? '';
+      return li;
+    }),
+  );
+});
+`;
+
+const VITE_CONFIG = `import { defineConfig } from 'vite';
+import { pyric } from '@pyric/cli/vite';
+
+// Under \`vite dev\` pyric() swaps firebase/* to the in-process pyric
+// sandbox and deploys + hot-reloads firestore.rules — no Firebase project,
+// credentials, or emulators. \`vite build\` (mode production) ships the real
+// firebase package; the swap never reaches the deployed artifact. For a
+// self-contained sandbox preview you can serve under \`pyric dev\`, build with a
+// non-production mode: \`vite build --mode development\` (see the \`build:sandbox\`
+// script). That output is marked and can never be deployed.
+export default defineConfig({
+  plugins: [pyric()],
+});
+`;
+
+const VITE_TSCONFIG = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["vite/client"]
+  },
+  "include": ["src"]
+}
+`;
+
+// Owner-based rules for the Vite web template. Same shape as the static
+// template's WEB_RULES, but the comment reflects the plugin (not pyric dev) —
+// keep this in lockstep with examples/vite-sandbox-app/firestore.rules.
+const VITE_RULES = `rules_version = '2';
+service cloud.firestore {
+  match /databases/{database}/documents {
+    // Owner-based from line 1 — the Vite plugin deploys + hot-reloads this file
+    // into the sandbox, so safe rules are cheap to iterate. These deploy as-is.
+    match /posts/{postId} {
+      allow read: if true;
+      allow create: if request.auth != null
+                    && request.resource.data.uid == request.auth.uid;
+      allow update, delete: if request.auth != null
+                            && resource.data.uid == request.auth.uid;
+    }
+
+    // Default deny — opt in per collection.
+    match /{document=**} {
+      allow read, write: if false;
+    }
+  }
+}
+`;
+
+const VITE_ENV_DTS = `/// <reference types="vite/client" />
+`;
+
+const VITE_FIREBASE_JSON = `{
+  "firestore": {
+    "rules": "firestore.rules",
+    "indexes": "firestore.indexes.json"
+  },
+  "hosting": {
+    "public": "dist",
+    "rewrites": [{ "source": "**", "destination": "/index.html" }]
+  }
+}
+`;
+
+const VITE_ENV_EXAMPLE = `# Your real Firebase web-app config (Firebase console -> project settings).
+# UNUSED in \`vite dev\` (the pyric sandbox stands in); USED by \`vite build\` for
+# production. Vite only exposes \`VITE_\`-prefixed vars to client code.
+VITE_FIREBASE_API_KEY=
+VITE_FIREBASE_AUTH_DOMAIN=
+VITE_FIREBASE_PROJECT_ID=
+VITE_FIREBASE_STORAGE_BUCKET=
+VITE_FIREBASE_MESSAGING_SENDER_ID=
+VITE_FIREBASE_APP_ID=
+`;
+
+const viteReadme = (name: string): string => `# ${name}
+
+A Firebase web app built with Vite. In development it runs entirely on pyric's
+in-process sandbox — no Firebase project, credentials, or emulators.
+
+- **Develop:** \`bun install && bun run dev\` — \`vite dev\` with the
+  \`@pyric/cli/vite\` plugin swapping \`firebase/*\` to the sandbox: seeded data,
+  your \`firestore.rules\` deployed + hot-reloaded, popup sign-in.
+- **Build for production:** \`bun run build\` — \`vite build\` ships the real
+  \`firebase\` package. Fill \`.env\` from the Firebase console (see
+  \`.env.example\`); the SAME config you wrote runs against real Firebase. There
+  is no separate "graduation" step — dev and prod are one toolchain.
+- **Deploy:** \`npx firebase-tools deploy\` after the production build
+  (\`hosting.public\` is \`dist/\`, Vite's build output).
+
+> Your app code uses canonical \`firebase/*\` imports everywhere. Switching
+> between the sandbox and real Firebase is \`vite dev\` vs \`vite build\`, never
+> what you wrote.
+
+The plugin is dev-only: SharedWorker multi-tab sync, \`--persist\`, capture, and
+the MCP bridge (all available today under \`pyric dev\`) arrive in the plugin in
+later releases. For a pre-built / no-build app, use \`pyric init --template static\`
++ \`pyric dev\`.
+`;
+
+let chatAssets: ReturnType<typeof loadAssetTemplate> | undefined;
+const getChatAssets = (): ReturnType<typeof loadAssetTemplate> =>
+  (chatAssets ??= loadAssetTemplate('chat'));
+
+// ─── the registry ─────────────────────────────────────────────────────
+
+export const TEMPLATES: Record<TemplateName, ScaffoldTemplate> = {
+  // web (default) — a Vite app on the @pyric/cli/vite plugin. `vite dev` runs
+  // on the sandbox; `vite build` ships real firebase. One toolchain.
+  web: {
+    scripts: {
+      dev: 'vite',
+      build: 'vite build',
+      'build:sandbox': 'vite build --mode development',
+     preview: 'vite preview',
+    },
+    // The real firebase package ships day one so the production `vite build`
+    // resolves the same canonical imports against it — no code edit at graduation.
+    dependencies: { firebase: '^12.12.0' },
+    devDependencies: { '@pyric/cli': '*', vite: '^6.0.0', typescript: '^5.7.0' },
+    dirs: ['src'],
+    files: (name) => [
+      { name: 'index.html', content: VITE_INDEX_HTML(name) },
+      { name: 'vite.config.ts', content: VITE_CONFIG },
+      { name: 'tsconfig.json', content: VITE_TSCONFIG },
+      { name: 'src/main.ts', content: VITE_MAIN_TS },
+      { name: 'src/vite-env.d.ts', content: VITE_ENV_DTS },
+      { name: 'firestore.rules', content: VITE_RULES },
+      { name: 'firebase.json', content: VITE_FIREBASE_JSON },
+      { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+      { name: '.env.example', content: VITE_ENV_EXAMPLE },
+      { name: 'README.md', content: viteReadme(name) },
+      { name: '.gitignore', content: GITIGNORE },
+    ],
+    nextSteps: [
+      'bun install',
+      'bun run dev    # vite dev on the pyric sandbox',
+      'bun run build  # production build against real Firebase',
+    ],
+  },
+  node: {
+    scripts: {
+      start: 'node --env-file-if-exists=.env --experimental-strip-types src/app.ts',
+      dev: 'pyric dev --no-open -- node --env-file-if-exists=.env --experimental-strip-types src/app.ts',
+     bridge: 'pyric bridge',
+    },
+    dependencies: { firebase: '^12.12.0' },
+    devDependencies: { '@pyric/cli': '*', '@types/node': '^22.0.0', typescript: '^5.7.0' },
+    dirs: ['src'],
+    files: (name) => [
+      { name: 'src/app.ts', content: NODE_APP_TS },
+      { name: '.env.example', content: NODE_ENV_EXAMPLE },
+      { name: 'src/seed.ts', content: NODE_SEED_TS },
+      { name: 'firestore.rules', content: NODE_RULES },
+      { name: 'firebase.json', content: NODE_FIREBASE_JSON },
+      { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+      { name: 'README.md', content: nodeReadme(name) },
+      { name: '.gitignore', content: GITIGNORE },
+    ],
+    nextSteps: ['bun install', 'bun run dev', 'bun start  # production: real Firebase'],
+  },
+  // static — the serve-era, no-bundler scaffold: a static app `pyric dev`
+  // runs against the in-page sandbox via a runtime import map. For pre-built /
+  // retrofit apps, or anyone who wants zero build step.
+  static: {
+    scripts: {
+      dev: 'pyric dev --seed seed.json',
+     'dev:agent': 'pyric dev --bridge --seed seed.json',
+    },
+    dependencies: { firebase: '^12.12.0' },
+    devDependencies: { '@pyric/cli': '*' },
+    dirs: ['public'],
+    files: (name) => [
+      { name: 'public/index.html', content: WEB_INDEX_HTML(name) },
+      { name: 'public/app.js', content: WEB_APP_JS },
+      { name: 'firestore.rules', content: WEB_RULES },
+      { name: 'firebase.json', content: WEB_FIREBASE_JSON },
+      { name: 'firestore.indexes.json', content: FIRESTORE_INDEXES },
+      { name: 'seed.json', content: WEB_SEED_JSON },
+      { name: '.env.example', content: WEB_ENV_EXAMPLE },
+      { name: 'README.md', content: webReadme(name) },
+      { name: '.gitignore', content: GITIGNORE },
+    ],
+    nextSteps: ['bun install', 'bun run dev', 'bun run dev:agent  # agents: MCP at /__pyric/mcp'],
+  },
+  chat: {
+    // Asset-backed templates stay lazy. The standalone binary imports
+    // create-pyric for ordinary CLI commands without embedding this package's
+    // on-disk template tree; eager reads would make even `pyric --version`
+    // fail before dispatch.
+    get scripts() { return getChatAssets().packageJson.scripts; },
+    get dependencies() { return getChatAssets().packageJson.dependencies; },
+    get devDependencies() { return getChatAssets().packageJson.devDependencies; },
+    get overrides() { return getChatAssets().packageJson.overrides; },
+    get dirs() { return getChatAssets().dirs; },
+    files: (name) => getChatAssets().files.map((file) => ({
+      name: file.name,
+      content: file.content.replaceAll('__PYRIC_PROJECT_NAME__', name),
+    })),
+    nextSteps: [
+      'npm install       # or: bun install',
+      'npm run dev       # scripted local AI by default',
+      'npm run typecheck',
+    ],
+  },
+};