pruff-skills 0.3.0 → 0.5.0

package/dist/cli.mjs

@@ -5,7 +5,7 @@ import { Ie, M, Me, Se, Y, be, fe, he, ve, xe, ye } from "./_chunks/libs/@clack/
 import { esm_default } from "./_chunks/libs/simple-git.mjs";
 import { xdgConfig } from "./_chunks/libs/xdg-basedir.mjs";
 import { require_dist } from "./_chunks/libs/@vercel/detect-agent.mjs";
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "fs";
+import { copyFileSync, cpSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { basename, dirname, isAbsolute, join, normalize, relative, resolve, sep } from "path";
 import { fileURLToPath } from "url";
 import { stripVTControlCharacters } from "node:util";
@@ -434,7 +434,7 @@ const CLONE_TIMEOUT_MS = (() => {
 	const parsed = Number.parseInt(raw, 10);
 	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_CLONE_TIMEOUT_MS;
 })();
-const execFileAsync$3 = promisify(execFile);
+const execFileAsync$4 = promisify(execFile);
 var GitCloneError = class extends Error {
 	url;
 	isTimeout;
@@ -513,7 +513,7 @@ async function resetTempDir(dir) {
 async function tryGhClone(repo, tempDir, ref) {
 	let cloneTarget = repo.slug;
 	try {
-		const { stdout, stderr } = await execFileAsync$3("gh", [
+		const { stdout, stderr } = await execFileAsync$4("gh", [
 			"auth",
 			"status",
 			"-h",
@@ -530,7 +530,7 @@ async function tryGhClone(repo, tempDir, ref) {
 	} catch {
 		return false;
 	}
-	await execFileAsync$3("gh", [
+	await execFileAsync$4("gh", [
 		"repo",
 		"clone",
 		cloneTarget,
@@ -3997,7 +3997,7 @@ function parseAddOptions(args) {
 		options
 	};
 }
-const execFileAsync$2 = promisify(execFile);
+const execFileAsync$3 = promisify(execFile);
 const claudeAgentsDir = (global) => global ? join(process.env.CLAUDE_CONFIG_DIR?.trim() || join(homedir(), ".claude"), "agents") : join(process.cwd(), ".claude", "agents");
 async function fetchAgentFile(source, name) {
 	const rel = `agents/${name}.md`;
@@ -4006,7 +4006,7 @@ async function fetchAgentFile(source, name) {
 		return existsSync(file) ? readFile(file, "utf8") : null;
 	}
 	if (/^[^/]+\/[^/]+$/.test(source)) try {
-		const { stdout } = await execFileAsync$2("gh", [
+		const { stdout } = await execFileAsync$3("gh", [
 			"api",
 			`repos/${source}/contents/${rel}`,
 			"--jq",
@@ -4103,7 +4103,7 @@ async function runAgents(args) {
 	console.log(`Unknown agents command: ${sub}`);
 	console.log(AGENTS_HELP);
 }
-const execFileAsync$1 = promisify(execFile);
+const execFileAsync$2 = promisify(execFile);
 const RULE_SCOPES = [
 	"client",
 	"server",
@@ -4120,7 +4120,7 @@ async function fetchFromCatalog(source, rel) {
 		return existsSync(file) ? readFile(file, "utf8") : null;
 	}
 	if (/^[^/]+\/[^/]+$/.test(source)) try {
-		const { stdout } = await execFileAsync$1("gh", [
+		const { stdout } = await execFileAsync$2("gh", [
 			"api",
 			`repos/${source}/contents/${rel}`,
 			"--jq",
@@ -4249,7 +4249,7 @@ async function runRules(args) {
 	const { names, options } = parseRulesOptions(sub === "add" || sub === "a" || sub === "install" || sub === "i" ? args.slice(1) : args);
 	await addRules(names, options);
 }
-const execFileAsync = promisify(execFile);
+const execFileAsync$1 = promisify(execFile);
 const RESET$3 = "\x1B[0m";
 const BOLD$3 = "\x1B[1m";
 const DIM$3 = "\x1B[38;5;102m";
@@ -4266,7 +4266,7 @@ async function fetchCatalogIndex(source) {
 		return JSON.parse(raw);
 	}
 	if (source.match(/^[^/]+\/[^/]+$/)) {
-		const { stdout } = await execFileAsync("gh", [
+		const { stdout } = await execFileAsync$1("gh", [
 			"api",
 			`repos/${source}/contents/${rel}`,
 			"--jq",
@@ -4618,7 +4618,7 @@ async function discoverNodeModuleSkills(cwd) {
 	}));
 	return skills;
 }
-async function runSync(args, options = {}) {
+async function runSync$1(args, options = {}) {
 	const cwd = process.cwd();
 	const agentResult = await detectAgent();
 	if (agentResult.isAgent) {
@@ -4883,7 +4883,7 @@ async function runInstallFromLock(args) {
 		M.info(`${import_picocolors.default.cyan(String(nodeModuleSkills.length))} skill${nodeModuleSkills.length !== 1 ? "s" : ""} from node_modules`);
 		try {
 			const { options: syncOptions } = parseSyncOptions(args);
-			await runSync(args, {
+			await runSync$1(args, {
 				...syncOptions,
 				yes: true,
 				agent: universalAgentNames
@@ -5250,7 +5250,7 @@ function buildUpdateInstallSource(entry) {
 	if (!entry.skillPath) return formatSourceInput(entry.sourceUrl, entry.ref);
 	return appendFolderAndRef(entry.source, entry.skillPath, entry.ref);
 }
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const __dirname$2 = dirname(fileURLToPath(import.meta.url));
 const RESET$1 = "\x1B[0m";
 const BOLD$1 = "\x1B[1m";
 const DIM$1 = "\x1B[38;5;102m";
@@ -5521,7 +5521,7 @@ async function updateGlobalSkills(options = {}) {
 		const safeName = sanitizeMetadata(update.name);
 		console.log(`${TEXT$1}Updating ${safeName}...${RESET$1}`);
 		const installUrl = buildUpdateInstallSource(update.entry);
-		const cliEntry = join(__dirname$1, "..", "bin", "cli.mjs");
+		const cliEntry = join(__dirname$2, "..", "bin", "cli.mjs");
 		if (!existsSync(cliEntry)) {
 			failCount++;
 			console.log(`  ${DIM$1}✗ Failed to update ${safeName}: CLI entrypoint not found at ${cliEntry}${RESET$1}`);
@@ -5605,7 +5605,7 @@ async function updateProjectSkills(options = {}) {
 		bySource.set(source, existing);
 	}
 	const localLock = await readLocalLock();
-	const cliEntry = join(__dirname$1, "..", "bin", "cli.mjs");
+	const cliEntry = join(__dirname$2, "..", "bin", "cli.mjs");
 	if (!existsSync(cliEntry)) {
 		console.log(`${DIM$1}✗ CLI entrypoint not found at ${cliEntry}${RESET$1}`);
 		return {
@@ -6126,16 +6126,557 @@ async function sweepLine(text, { slow = false, indent = "  " } = {}) {
 		process.stdout.write("\x1B[?25h");
 	}
 }
+function rowColor(palette, row) {
+	return palette[row % palette.length];
+}
+function printStaticBlockLogo(lines, palette) {
+	lines.forEach((line, i) => console.log(`${rowColor(palette, i)}${line}${RESET}`));
+}
+function renderBlockLogoReveal(lines, palette, cut, width) {
+	return lines.map((line, i) => {
+		const shown = Array.from(line).slice(0, cut);
+		const pad = " ".repeat(Math.max(0, width - shown.length));
+		return `${rowColor(palette, i)}${shown.join("")}${RESET}${pad}`;
+	}).join("\n");
+}
+function renderBlockLogoFrame(lines, palette, pos, band) {
+	return lines.map((line, i) => {
+		const chars = Array.from(line);
+		let out = "";
+		let mode = "";
+		for (let c = 0; c < chars.length; c++) {
+			const color = c >= pos && c < pos + band ? SWEEP : rowColor(palette, i);
+			if (color !== mode) {
+				out += color;
+				mode = color;
+			}
+			out += chars[c];
+		}
+		return out + RESET;
+	}).join("\n");
+}
+async function showBlockLogo(lines, letterCuts, { slow = false, palette = BLUES } = {}) {
+	console.log();
+	if (!canAnimate()) {
+		printStaticBlockLogo(lines, palette);
+		return;
+	}
+	const rows = lines.length;
+	const width = Math.max(...lines.map((l) => Array.from(l).length));
+	const band = 7;
+	const revealMs = slow ? 190 : 90;
+	const step = slow ? 3 : 4;
+	const sweepMs = slow ? 34 : 18;
+	process.stdout.write("\x1B[?25l");
+	try {
+		let first = true;
+		for (const cut of letterCuts) {
+			if (!first) process.stdout.write(`\x1b[${rows}A`);
+			process.stdout.write("\r" + renderBlockLogoReveal(lines, palette, cut, width) + "\n");
+			first = false;
+			await sleep(revealMs);
+		}
+		for (let pos = -7; pos <= width; pos += step) {
+			process.stdout.write(`\x1b[${rows}A`);
+			process.stdout.write("\r" + renderBlockLogoFrame(lines, palette, pos, band) + "\n");
+			await sleep(sweepMs);
+		}
+		process.stdout.write(`\x1b[${rows}A\r`);
+		process.stdout.write(lines.map((line, i) => `${rowColor(palette, i)}${line}${RESET}`).join("\n") + "\n");
+		if (slow) await sleep(500);
+	} finally {
+		process.stdout.write("\x1B[?25h");
+	}
+}
+const WORKSPACE_CLAUDE_TEMPLATE = `# Pruff — Working Directory
+
+This folder is the working directory for Pruff's frontend and backend. The two main git repos are:
+
+- **\`Pruff-Client/\`** — React frontend
+- **\`Pruff-server/\`** — Node.js/Express backend
+
+Other directories (\`sls-*/\`, \`slsl-*/\`, \`AWS-Tools/\`, etc.) are serverless microservices and tooling —
+clone them into this workspace as you need them, and don't modify them unless explicitly asked.
+
+Each repo has its own \`CLAUDE.md\` and \`.claude/rules/\` with repo-specific patterns. This file covers
+workspace-level context only.
+
+---
+
+## Workspace Layout
+
+### Main applications (modify freely when asked)
+
+| Folder | What it is |
+|---|---|
+| \`Pruff-Client/\` | React 18 + Vite + MUI frontend. React Query + Redux Toolkit. |
+| \`Pruff-server/\` | Node.js 22 / Express / Prisma backend. Multi-tenant (DB-per-tenant). |
+
+### Serverless microservices (\`sls-*/\`, \`slsl-*/\` — clone as needed, don't modify unless asked)
+
+All live in the same AWS account, share the \`lambda-sqs\` IAM role, and most use a shared
+\`prisma-client-layer\` Lambda layer so they can reach tenant databases. They talk to \`Pruff-server\`
+over HTTPS with an \`x-api-key\`.
+
+| Folder | Role |
+|---|---|
+| \`sls-SII-Services/\` | **SII (Chilean tax authority) scrapers & orchestrators.** Invoice generation, certificate validation, cession execution, F29/IVA extraction, credit-note references, cron orchestrators. Talks heavily to \`slsl-Data-Injection-Syncronizer\`. |
+| \`sls-TGR-Extraction/\` | **TGR (treasury) scrapers.** Extracts tax collections, debts, payment agreements. Pushes results into the data-injection pipeline. |
+| \`sls-TGR-Services/\` | **TGR-adjacent business logic.** Smaller sibling to \`sls-TGR-Extraction\`. |
+| \`sls-Public-Market/\` | **Mercado Público (Chilean public tenders) pipeline.** Awarded-tender fetcher, tender analyzer, lead generator. |
+| \`slsl-Data-Injection-Syncronizer/\` | **Fan-out hub between scrapers and Pruff-server.** Receives scraped data, resolves interested tenants, forwards per-tenant writes. Also hosts the \`ReflexOrchestrator\` change-detection pipeline. |
+| \`sls-Decision-Engine/\` | **Risk / Motor de Riesgo executor.** Three-stage SQS pipeline: \`prepare\` → \`delayedPrepare\` → \`executor\`. |
+| \`sls-Notification-Service/\` | **Outbound notifications** (email, in-app, collections). |
+| \`sls-Pruff-Webhooks/\` | **Outbound webhook delivery** to client integrations. |
+| \`sls-Pruff-Workers/\` | **Async background jobs for Pruff-server** (PDF rendering, tenant document/summary sync crons). |
+
+### Tooling & utilities
+
+| Folder | What it is |
+|---|---|
+| \`AWS-Tools/\` | Standalone Node/TypeScript scripts for AWS ops — not deployed; run locally with AWS creds. |
+
+### Cross-service data flow (mental model)
+
+\`\`\`
+sls-SII-Services ─┐
+sls-TGR-Extraction ├─► slsl-Data-Injection-Syncronizer ─► Pruff-server (per-tenant DBs)
+sls-Public-Market ─┘                          │
+                                              ▼
+                                    sls-Decision-Engine ──► Pruff-server
+                                              │
+                                              ▼
+                    sls-Notification-Service / sls-Pruff-Webhooks (outbound)
+\`\`\`
+
+\`sls-Pruff-Workers\` sits beside \`Pruff-server\` handling async/scheduled jobs that would block the API.
+
+---
+
+## What is Pruff
+
+Pruff is a **multi-tenant B2B fintech platform** for Latin American financing institutions (factorings,
+credit companies, investment funds). It centralizes the full lifecycle of financial operations through
+three integrated modules:
+
+\`\`\`
+DataHub (data ingestion) → Motor de Riesgo (risk/decision engine) → Core (operations)
+         ↑_________________________retroalimentación_________________________↓
+\`\`\`
+
+- **DataHub** — Consolidates client, debtor, and market data from external sources (SII, TGR, Bureau, banks).
+- **Motor de Riesgo** — Applies configurable scoring rules, compliance checks, exposure limits, and alerts.
+- **Core (FinancingHub)** — Executes approved operations: cesiones, disbursements, payment schedules,
+  collections, reconciliation, and double-entry accounting.
+
+### Financial Products
+
+| Product | What It Does |
+|---------|-------------|
+| **Factoring** | Client sells unpaid invoices for immediate liquidity. Core product. |
+| **Credits** | Structured financing with cuotas (installments) |
+| **Confirming** | Accelerated supplier payments (accounts payable) |
+| **Credit Lines** | Pre-approved revolving credit with partial draws |
+| **Funds** | Real-time visibility for investment funds over factoring portfolios |
+
+---
+
+## Multi-Tenancy Architecture
+
+**Critical concept:** Pruff is **database-per-tenant**. Every tenant has its own MySQL database.
+
+1. User authenticates via JWT → \`secretId\` extracted from company
+2. \`PrismaClientManager.getTenantClient(secretId)\` returns a tenant-scoped Prisma client
+3. **Every service that needs DB access receives \`prisma\` (tenant-scoped) as its first parameter**
+4. Use \`prismaGlobal\` only when the use case requires cross-tenant or shared data
+
+---
+
+## Pruff-server (Backend)
+
+**Stack:** Node.js 22, Express 4, TypeScript 5, Prisma 5, MySQL 8, AWS (S3, SQS, SNS, Lambda, DynamoDB)
+**Package manager:** \`bun\` — \`bun.lock\` is the canonical lockfile. Use \`bun install\` / \`bun add <pkg>\`,
+never \`npm install\` or \`yarn\` (Docker/CI install with \`bun install --frozen-lockfile\`, so an
+npm/yarn-only change goes stale). \`npm run <script>\` still works for running scripts.
+
+### Commands
+
+\`\`\`bash
+cd Pruff-server
+
+npm run local              # Run locally (uses local.env)
+npm run dev                # Run against dev environment (uses dev.env)
+npm run build              # Compile TypeScript (tsc + tsc-alias)
+npm run test               # Jest tests (uses test.env, sequential with 1 worker)
+npm run test:file <name>   # Run single jest test by file name (not path)
+npm run lint               # ESLint
+
+# Database (Prisma)
+npm run db-update-local    # prisma migrate dev (create + apply migration, local)
+npm run db-migrate-local   # prisma migrate deploy (apply existing migrations, local)
+npm run db-migrate-tenants-local  # Migrate all tenant databases
+npm run db-seed-tenants-local     # Seed all active tenant databases
+\`\`\`
+
+### Source Structure
+
+\`\`\`
+src/
+  controllers/     # Thin — validate input, call service, return response
+  services/        # All business logic, organized by domain
+  routes/
+    api.ts         # Main router
+    internal/      # Staff endpoints (JWT auth)
+    clients/       # Customer-facing endpoints (API key)
+    external/      # Scraper/lambda endpoints (API key)
+    public/        # No auth
+  modules/         # Infrastructure wrappers (S3, SQS, SII, GoFirmex, etc.)
+  middlewares/     # Auth, tenant resolution, rate limiting, error handling
+  jobs/            # Cron jobs (iterate over all tenants)
+  types/           # Shared TypeScript types
+  lib/             # Utility functions
+\`\`\`
+
+### API Tiers
+
+| Tier | Base Route | Auth | Middleware |
+|------|-----------|------|-----------|
+| Internal | \`/api/internal\` | JWT | \`authenticateJWT\` + \`attachUserPermissions\` |
+| External | \`/api/external\` | API Key | \`authenticateWithApiKey\` |
+| Clients | \`/api/clients\` | Client API Key | \`authenticateClientsWithApiKey\` |
+| Public | \`/api/public\` | None | — |
+
+### Service Pattern — Result\\<T\\>
+
+All services return \`Result<T>\`. Never throw from services.
+
+\`\`\`typescript
+type Result<T> = { ok: true; value: T } | { ok: false; error: AppError };
+
+return { ok: true, value };
+return { ok: false, error: { status: APP_CODES.NOT_FOUND, message: 'NOT_FOUND', service: 'MyService', displayMessage: 'No encontrado' } };
+\`\`\`
+
+### Controller Pattern — handleApiOutput / handleApiError
+
+\`\`\`typescript
+async someAction(req: UserRequest, res: Response) {
+  try {
+    const result = await SomeService.execute(req.prisma, req.body);
+    return handleApiOutput('SomeService', req, res, result);
+  } catch (error) {
+    handleApiError('SomeService', req, res, error);
+  }
+}
+\`\`\`
+
+### Naming Conventions
+
+- **Services:** \`PascalCase\` + \`Service\` suffix → \`CreateFactoringRequestService.ts\`
+- **DTOs/interfaces:** \`PascalCase\` + \`Dto\` suffix → \`CreateFactoringRequestDto\`
+- **Controllers:** \`camelCase\` + \`Controller\` suffix → \`invoicesController.ts\`
+- **Services are singletons:** \`export default new MyService();\`
+- **\`prisma\` is always the first parameter** when the service needs DB access
+
+### Accounting Rules
+
+- Every financial state change generates double-entry accounting entries automatically
+- \`SUM(debit) === SUM(credit)\` always — imbalanced entries are rejected
+- Entries use \`sourceKey\` to prevent duplicates and \`checkSum\` (SHA256) for audit integrity
+- Periods must be OPEN to accept entries
+
+### Environment Files
+
+- \`local.env\` — local MySQL, mocked AWS services
+- \`dev.env\` — connects to \`api.dev.pruff.com\` dependencies
+- \`test.env\` — for Jest tests
+
+---
+
+## Pruff-Client (Frontend)
+
+**Stack:** React 18, TypeScript, Vite, MUI v5, Redux Toolkit, TanStack React Query v5, Axios
+**Package manager:** \`yarn\` — \`yarn.lock\` is the canonical lockfile.
+
+### Commands
+
+\`\`\`bash
+cd Pruff-Client
+
+yarn start-local  # Dev server → backend at http://localhost:80
+yarn start-dev    # Dev server → backend at https://api.dev.pruff.com
+yarn start-prod   # Dev server → backend at https://api.pruff.com
+yarn build        # Production build
+yarn lint         # ESLint
+yarn test         # Jest + React Testing Library
+\`\`\`
+
+### Source Structure
+
+\`\`\`
+src/
+  pages/           # Feature modules
+  lib/
+    api/           # Axios API integration modules
+    designSystem/  # Shared MUI-based components
+    mobileDesignSystem/  # Mobile-specific components
+    common/        # Domain-specific shared components
+    hooks/         # Custom React hooks
+    functions/     # Business logic functions (utils.ts, permission checks)
+    types/         # TypeScript type definitions
+  services/        # Redux store + API configuration (requestHandler)
+  layouts/         # Layout components
+  assets/          # Images, fonts, icons
+\`\`\`
+
+### State Management
+
+- **React Query v5** — All server data (fetching, caching, mutations)
+- **Redux Toolkit** — Auth state, global alerts, client branding config only
+- **Redux Persist** — Persists auth across sessions
+
+### API Client
+
+All HTTP goes through \`requestHandler\` (Axios wrapper in \`src/lib/api.ts\`). Import from the relevant
+module in \`src/lib/api/<domain>/\`.
+
+### Permission System
+
+RBAC via \`user.roles[].permissions[].name\`. Key utilities in \`src/lib/functions/utils.ts\`:
+- \`validatePermissions(user, permission)\` — single check
+- \`hasAnyPermissions(user, permissions[])\` — OR logic
+- \`validateCompanyTypes(user, type)\` — product/feature gating
+
+---
+
+## Code Style (Both Repos)
+
+- **Prettier:** \`printWidth: 80\`, \`singleQuote: true\`, \`trailingComma: 'all'\`, \`semi: true\`
+- **ESLint:** TypeScript strict, \`simple-import-sort\` enforced, \`no-console\` (warn/error)
+- **Import order** (enforced): external packages → absolute imports → relative imports, alphabetically sorted
+
+---
+
+## Chile-Specific Concepts
+
+| Term | Meaning |
+|------|---------|
+| **RUT** | Chilean tax ID (e.g., \`12.345.678-9\`) |
+| **DTE** | Electronic tax document (33=factura, 34=exenta, 61=nota de crédito) |
+| **SII** | Servicio de Impuestos Internos — tax authority, source of invoices, F22, F29 |
+| **F22/F29** | Annual/monthly tax returns |
+| **TGR** | Tesorería General de la República — state treasury, tax debts |
+| **UF** | Unidad de Fomento — daily inflation-adjusted unit (CMF publishes value) |
+| **CMF** | Comisión para el Mercado Financiero — financial markets regulator |
+| **SGR** | Sociedad de Garantía Recíproca — mutual guarantee society for SMEs |
+| **Cedente** | Client selling receivables (factoring seller) |
+| **Deudor** | Invoice payer / debtor |
+| **Cesión** | Transfer of collection rights on an invoice |
+| **Giro/Desembolso** | Cash disbursement |
+| **Cobranza** | Collection management |
+| **Mora** | Payment delinquency |
+| **Conciliación** | Reconciling bank movements with operations |
+| **Provisión** | Recognized expected loss |
+| **Castigo** | Write-off of uncollectible amounts |
+| **Bureau** | Credit bureau with RUT-level payment history |
+| **Spread** | Profit margin between funding cost and lending rate |
+
+---
+
+## Pruff Knowledge
+
+Durable, versioned knowledge (standards, architecture, how things work) lives in the \`Pruff Knowledge/\`
+repo cloned alongside this workspace by onboarding (\`Pruff-Tech/pruff-knowledge\`). Read it for context
+beyond this CLAUDE.md. Roadmap, releases, meeting notes, and tickets stay in Notion/Linear, not here.
+
+**Start at a MOC** (\`_moc/\` — Maps of Content): the curated entry index per area. From there, follow the
+\`[[wikilinks]]\` to the concrete notes, or jump straight into the folder you need.
+
+| Folder | What it covers |
+|---|---|
+| \`architecture/\` | Patterns and standards already implemented (SSE, error handling, multi-tenancy, database gateway…) |
+| \`infrastructure/\` | AWS services, ECS, Lambdas, and how they connect |
+| \`design-system/\` | UI components, tokens, and conventions |
+| \`operations/\` | Operational flow, modules, and how they fit together |
+| \`integrations/\` | Existing integrations and how they're used |
+| \`repos/\` | One doc per repository — what it does and how it connects |
+| \`guides/\` | How-tos (internal and external) |
+| \`glossary/\` | Domain terms — folio, cesión, RUT, mora, etc. |
+| \`postmortems/\` | Incidents — root cause and durable learnings (operational detail stays in Linear) |
+
+Notes are frontmatter/filenames in English (\`kebab-case\`), body in Spanish. See the repo's own
+\`AGENTS.md\` for the agent-facing contract.
+
+---
+
+## Workflow
+
+- **Always use \`/commit\`** — invoke the \`commit\` skill for all git commits. Never run \`git commit\` manually.
+- **Always use \`/create-pr\`** — invoke the \`create-pr\` skill for all pull requests. Never run \`gh pr create\` manually.
+- **Commits are authored to the human running Claude Code** — never set \`--author\` to Claude or any co-author.
+- **In \`sls-*/\` and \`slsl-*/\` repos, branch from \`origin/main\`** — verify this against each repo's actual
+  \`dev\` vs \`main\` state before assuming; it has drifted before. Exception: \`Pruff-server\` and
+  \`Pruff-Client\` branch from \`dev\` (their deploy flow promotes \`dev → main\`).
+- **Branch names embed the Linear issue code; PRs map 1:1 with Linear issues** — name branches so they
+  contain the issue code (e.g. \`pru-1355-...\`) for Linear's git automation. When splitting work, plan
+  the PR grouping first, create one Linear issue per PR (1:1), and stack dependent PRs
+  (\`dev ← group-1 ← group-2 ← …\`) instead of one mega-PR. If more than one linear issue is in one PR, name of the branch
+  should be the linear issue code of each issue.
+- **Be straightforward and concise** — lead with the core message, then the minimum supporting detail.
+  Cut preamble and narration. When asked for a table or diagram, render real markdown, never a bullet
+  list dressed up as one.
+- **Propose options and confirm before acting** — for any non-trivial design, format, or refactor choice,
+  present alternatives with their tradeoffs in chat and wait for a pick before writing code or running
+  commands. Gather context → confirm the plan → build.
+- **Explain the rationale, not just the diff** — when a change touches a non-obvious file (a new
+  middleware, a \`Dockerfile\` edit, a cap/limit) or you're proposing an approach, explain in chat *why*
+  it's needed and surface the cons/tradeoffs before adopting it.
+- **Numbers are verified facts, not estimates** — before stating a count, rate, latency, or cost, confirm
+  it from the source (logs, metrics, a query) and cite the source + window inline. If you can't verify
+  it, label it an estimate or omit it. Package-manager conventions, canonical branches, and other
+  "what does this repo actually do" questions belong in this bucket too — check \`origin/main\`, not a
+  possibly-stale local checkout or this file.
+- **Register out-of-scope findings in \`.claude/smell-findings/\`** — whenever you or a subagent spots a
+  code smell, an unrelated bug, or an improvement opportunity outside the current task's scope, record
+  it as a markdown file there instead of fixing it inline or dropping it.
+- Delegate context gathering to codebase-navigator agent if present, and implementation to implementer agent if present.
+
+---
+
+## Code Review
+
+When reviewing PRs, always scope scans to the PR's changed files (never the whole repo). For
+react-doctor/diff tools, use PR-scoped diffs and manually verify risky logic.
+
+---
+
+## Critical Rules
+
+1. **Every backend service takes \`prisma\` as its first parameter** — tenant isolation depends on it.
+   Never import or use a global Prisma instance inside a service.
+2. **Services return \`Result<T>\`, never throw** — controllers handle the Result pattern.
+3. **Accounting entries must balance** — debit total must equal credit total.
+4. **Financial operations are fully auditable** — CloudWatch logs and approval chains must not be skipped.
+5. **SII/RUT data is sensitive** — Credentials are encrypted via \`encryptionModule\`.
+6. **Never modify \`prisma/schema.prisma\` without confirmation** — schema changes affect every tenant database.
+7. **Never run DB migrations automatically** — propose the change and let the developer run it.
+8. **Never push directly to \`dev\` or \`main\`** — all changes must go through a PR. No exceptions.
+`;
+const CONTROL_PLANE_PRESEED_SCRIPT = `import { PrismaClient } from '@prisma/client';
+
+import seedRoles from './prisma/seeds/roles';
+import seedPermissions from './prisma/seeds/permissions';
+import seedRolesWithPermissions from './prisma/seeds/permissionsToRole';
+import seedCompanyTypes from './prisma/seeds/companyTypes';
+
+const prisma = new PrismaClient();
+
+async function main() {
+  if ((await prisma.role.count()) === 0) await seedRoles();
+  if ((await prisma.permission.count()) === 0) await seedPermissions();
+  await seedRolesWithPermissions();
+  await seedCompanyTypes();
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(() => process.exit(0));
+`;
+const TENANT_USER_BACKFILL_SCRIPT = `import PrismaClientManager from './src/modules/prismaClient';
+import EncryptionModule from './src/modules/encryptionModule';
+
+async function main() {
+  const email = process.argv[2];
+  const password = process.argv[3];
+  const clientId = process.env.CLIENT_ID;
+  if (!clientId) throw new Error('CLIENT_ID is required');
+
+  const tenantPrisma = PrismaClientManager.getGlobalClient();
+  const existing = await tenantPrisma.user.findFirst({ where: { email } });
+  if (existing) {
+    console.log('tenant user already present: ' + email);
+    return;
+  }
+
+  const globalPrisma = PrismaClientManager.getGlobalClientFromTenantBase(clientId);
+  const globalUser = await globalPrisma.user.findFirstOrThrow({ where: { email } });
+  const encryptedPassword = await EncryptionModule.encrypt(password);
+
+  await tenantPrisma.user.create({
+    data: {
+      id: globalUser.id,
+      email,
+      name: email.split('@')[0],
+      password: encryptedPassword,
+      active: true,
+      companyId: globalUser.companyId,
+      roles: { connect: [{ id: 4 }] },
+    },
+  });
+  console.log('tenant user created: ' + email + ' (id=' + globalUser.id + ')');
+}
+
+main()
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  })
+  .finally(() => process.exit(0));
+`;
+function renderLocalEnv(v) {
+	const q = (value) => `"${value.replace(/"/g, "\\\"")}"`;
+	return `DATABASE_URL=${q(`mysql://root@localhost:3306/pruff-local?connection_limit=5`)}
+NODE_ENV="local"
+IS_LOCAL_ENV="true"
+CLIENT_ID=${q(v.clientId)}
+CLIENT_RUT=${q(v.clientRut)}
+CLIENT_NAME=${q(v.clientName)}
+ADMIN_PASSWORD=${q(v.adminPassword)}
+JWT_SECRET=${q(v.jwtSecret)}
+API_KEY=${q(v.apiKey)}
+SECRET_SII_KEY=${q(v.siiKey)}
+SECRET_USER_REGISTRATION=${q(v.registrationSecret)}
+SECRET_PFX_CERTIFICATE=${q(v.pfxSecret)}
+USER_FORM_KEY=${q(v.userFormKey)}
+POSTHOG_ENABLED="false"
+
+# --- Third-party integrations -------------------------------------------------
+# Left blank on purpose. Fill with real sandbox credentials from your team /
+# 1Password when you need the feature. The app boots and serves local data
+# without them.
+SII_SERVICE_URL=""
+SII_SERVICE_APIKEY=""
+TGR_SERVICE_URL=""
+TGR_SERVICE_APKEY=""
+AWS_ACCESS_KEY_ID=""
+AWS_SECRET_ACCESS_KEY=""
+POSTHOG_API_KEY=""
+POSTHOG_HOST=""
+BURO_USERNAME=""
+BURO_PASSWORD=""
+BURO_API_URL=""
+CMF_API_KEY=""
+MCP_OAUTH_PUBLIC_KEY=""
+MCP_ALLOWED_TENANTS=""
+`;
+}
 const CLAUDE_CODE_PKG = "@anthropic-ai/claude-code";
 const KNOWLEDGE_REPO = "https://github.com/Pruff-Tech/pruff-knowledge";
 const KNOWLEDGE_DIR = "Pruff Knowledge";
 const DEFAULT_WORKSPACE = join(homedir(), "pruff");
 const MAIN_REPOS = [{
 	name: "Pruff-server",
-	url: "https://github.com/Pruff-Tech/Pruff-server"
+	url: "https://github.com/Pruff-Tech/Pruff-server",
+	installCmd: "bun",
+	installArgs: ["install"]
 }, {
 	name: "Pruff-Client",
-	url: "https://github.com/Pruff-Tech/Pruff-Client"
+	url: "https://github.com/Pruff-Tech/Pruff-Client",
+	installCmd: "yarn",
+	installArgs: ["install"]
 }];
 const CORE_SKILLS = [
 	"commit",
@@ -6161,12 +6702,16 @@ async function runOnboarding(args) {
 	Ie(import_picocolors.default.bold("Pruff onboarding"));
 	installClaudeCode();
 	ensureObsidian();
+	ensureBun();
 	const workspace = await resolveWorkspace(args);
 	mkdirSync(workspace, { recursive: true });
 	M.success(`Workspace ${import_picocolors.default.cyan(workspace)}`);
 	cloneKnowledge(workspace);
-	for (const repo of MAIN_REPOS) cloneRepo(repo.name, repo.url, workspace);
+	for (const repo of MAIN_REPOS) cloneRepo(repo, workspace);
+	for (const repo of MAIN_REPOS) installDeps(repo, workspace);
+	writeWorkspaceClaudeMd(workspace);
 	await installCatalog(workspace);
+	if (await shouldSetupDatabase(args)) await setupLocalEnvironment(join(workspace, "Pruff-server"));
 	await showGuidance(workspace);
 	Se(`${import_picocolors.default.green("Done.")} Welcome to Pruff — happy building.`);
 }
@@ -6176,12 +6721,30 @@ function has(cmd) {
 		stdio: "ignore"
 	}).status === 0;
 }
-function run(cmd, args, cwd) {
+function run(cmd, args, cwd, env) {
 	return spawnSync(cmd, args, {
 		stdio: "inherit",
-		cwd
+		cwd,
+		env: env ? {
+			...process.env,
+			...env
+		} : void 0
 	}).status === 0;
 }
+function capture(cmd, args, cwd, env) {
+	const r = spawnSync(cmd, args, {
+		encoding: "utf-8",
+		cwd,
+		env: env ? {
+			...process.env,
+			...env
+		} : void 0
+	});
+	return {
+		ok: r.status === 0,
+		out: (r.stdout ?? "").trim()
+	};
+}
 function expandHome(input) {
 	return input.startsWith("~") ? join(homedir(), input.slice(1)) : input;
 }
@@ -6223,6 +6786,19 @@ function ensureObsidian() {
 		M.warn(`Install manually: ${import_picocolors.default.cyan("brew install --cask obsidian")}`);
 	}
 }
+function ensureBun() {
+	if (has("bun")) {
+		M.success("Bun already installed");
+		return;
+	}
+	const s = Y();
+	s.start("Installing Bun…");
+	if (run("bash", ["-c", "curl -fsSL https://bun.sh/install | bash"])) s.stop("Bun installed");
+	else {
+		s.stop(import_picocolors.default.yellow("Bun install failed"));
+		M.warn(`Install it manually: ${import_picocolors.default.cyan("curl -fsSL https://bun.sh/install | bash")} (or ${import_picocolors.default.cyan("brew install oven-sh/bun/bun")})`);
+	}
+}
 async function resolveWorkspace(args) {
 	const fromArg = args.find((a) => !a.startsWith("-"));
 	if (fromArg) return expandHome(fromArg);
@@ -6266,7 +6842,8 @@ function cloneKnowledge(workspace) {
 	s.stop(import_picocolors.default.yellow("Knowledge clone failed"));
 	M.warn(`Could not clone ${import_picocolors.default.cyan(KNOWLEDGE_REPO)}.\n  It's private — authenticate first with ${import_picocolors.default.cyan("gh auth login")} (or an SSH key), then re-run.`);
 }
-function cloneRepo(name, url, workspace) {
+function cloneRepo(repo, workspace) {
+	const { name, url } = repo;
 	const target = join(workspace, name);
 	if (existsSync(join(target, ".git"))) {
 		M.success(`${name} already cloned`);
@@ -6284,6 +6861,33 @@ function cloneRepo(name, url, workspace) {
 		M.warn(`Could not clone ${name}. Authenticate with ${import_picocolors.default.cyan("gh auth login")} then run:\n  ${import_picocolors.default.dim(`git clone ${url}`)}  (inside ${workspace})`);
 	}
 }
+function installDeps(repo, workspace) {
+	const { name, installCmd, installArgs } = repo;
+	const target = join(workspace, name);
+	if (!existsSync(join(target, ".git"))) return;
+	if (!has(installCmd)) {
+		M.warn(`${import_picocolors.default.cyan(installCmd)} not found — skipping ${name} dependency install.\n  Run manually once installed: ${import_picocolors.default.dim(`cd ${name} && ${installCmd} ${installArgs.join(" ")}`)}`);
+		return;
+	}
+	const s = Y();
+	s.start(`Installing ${name} dependencies (${installCmd})…`);
+	const ok = run(installCmd, installArgs, target);
+	if (ok && existsSync(join(target, "node_modules"))) s.stop(`${name} dependencies installed`);
+	else {
+		s.stop(import_picocolors.default.yellow(`${name} dependency install failed`));
+		if (ok) M.warn(`${installCmd} exited 0 but ${name}/node_modules is missing — install likely no-opped.`);
+		M.warn(`Run manually: ${import_picocolors.default.dim(`cd ${name} && ${installCmd} ${installArgs.join(" ")}`)}`);
+	}
+}
+function writeWorkspaceClaudeMd(workspace) {
+	const target = join(workspace, "CLAUDE.md");
+	if (existsSync(target)) {
+		M.success("Workspace CLAUDE.md already present — leaving it untouched");
+		return;
+	}
+	writeFileSync(target, WORKSPACE_CLAUDE_TEMPLATE, "utf-8");
+	M.success("Wrote workspace CLAUDE.md");
+}
 async function installCatalog(workspace) {
 	const prevCwd = process.cwd();
 	M.step("Installing Pruff rules, agents and skills into the workspace…");
@@ -6302,6 +6906,272 @@ async function installCatalog(workspace) {
 		process.chdir(prevCwd);
 	}
 }
+async function setupLocalEnvironment(serverPath) {
+	if (!existsSync(join(serverPath, ".git"))) {
+		M.warn("Pruff-server not cloned — skipping local database setup.");
+		return;
+	}
+	if (!ensureMysql()) return;
+	ensureDbeaver();
+	generateLocalEnv(serverPath);
+	const env = parseEnvFile(join(serverPath, "local.env"));
+	if (!env.DATABASE_URL || !env.CLIENT_ID) {
+		M.warn("local.env is missing DATABASE_URL / CLIENT_ID — skipping database setup.");
+		return;
+	}
+	setupLocalDatabase(serverPath, env);
+}
+async function shouldSetupDatabase(args) {
+	if (args.includes("--no-db")) return false;
+	if (args.includes("--db")) return true;
+	if (!process.stdout.isTTY) return false;
+	const answer = await ye({
+		message: "Set up the local Pruff-server database now? (installs MySQL + DBeaver, migrates both DBs, seeds a local \"pruff\" tenant)",
+		initialValue: true
+	});
+	if (pD(answer)) return false;
+	return answer === true;
+}
+function ensureMysql() {
+	if (!has("mysql")) {
+		if (!has("brew")) {
+			M.warn(`MySQL not found and Homebrew is unavailable.\n  Install MySQL, then re-run: ${import_picocolors.default.cyan("npx pruff-skills onboarding --db")}`);
+			return false;
+		}
+		const s = Y();
+		s.start("Installing MySQL (brew)…");
+		const ok = run("brew", ["install", "mysql"]);
+		s.stop(ok ? "MySQL installed" : import_picocolors.default.yellow("MySQL install failed"));
+		if (!ok) return false;
+	} else M.success("MySQL already installed");
+	if (mysqlRunning()) {
+		M.success("MySQL already running");
+		return true;
+	}
+	const s = Y();
+	s.start("Starting MySQL…");
+	run("brew", [
+		"services",
+		"start",
+		"mysql"
+	]);
+	for (let i = 0; i < 30 && !mysqlRunning(); i++) spawnSync("sleep", ["1"]);
+	const up = mysqlRunning();
+	s.stop(up ? "MySQL running" : import_picocolors.default.yellow("MySQL did not come up"));
+	if (!up) M.warn(`Start it manually: ${import_picocolors.default.cyan("brew services start mysql")}, then re-run with --db.`);
+	return up;
+}
+function mysqlRunning() {
+	return spawnSync("mysqladmin", [
+		"ping",
+		"-u",
+		"root",
+		"--silent"
+	], { stdio: "ignore" }).status === 0;
+}
+function ensureDbeaver() {
+	if (existsSync("/Applications/DBeaver.app")) {
+		M.success("DBeaver already installed");
+		return;
+	}
+	if (!has("brew")) {
+		M.warn(`DBeaver not found. Install it from ${import_picocolors.default.cyan("https://dbeaver.io")}.`);
+		return;
+	}
+	const s = Y();
+	s.start("Installing DBeaver (brew)…");
+	const ok = run("brew", [
+		"install",
+		"--cask",
+		"dbeaver-community"
+	]);
+	s.stop(ok ? "DBeaver installed" : import_picocolors.default.yellow("DBeaver install failed"));
+}
+function generateLocalEnv(serverPath) {
+	const target = join(serverPath, "local.env");
+	if (existsSync(target)) {
+		M.success("local.env already present — leaving it untouched");
+		return;
+	}
+	const secret = () => randomBytes(16).toString("hex");
+	writeFileSync(target, renderLocalEnv({
+		clientId: "pruff",
+		clientRut: "99.999.999-9",
+		clientName: "Pruff Local",
+		adminPassword: "pruff-local-1234",
+		jwtSecret: secret(),
+		apiKey: secret(),
+		siiKey: secret(),
+		registrationSecret: secret(),
+		pfxSecret: secret(),
+		userFormKey: secret()
+	}), "utf-8");
+	M.success("Wrote local.env (minimal bootable — fill third-party keys when needed)");
+}
+function parseEnvFile(path) {
+	if (!existsSync(path)) return {};
+	const out = {};
+	for (const raw of readFileSync(path, "utf-8").split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+		const eq = line.indexOf("=");
+		if (eq === -1) continue;
+		const key = line.slice(0, eq).trim();
+		let value = line.slice(eq + 1).trim();
+		if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) value = value.slice(1, -1);
+		out[key] = value;
+	}
+	return out;
+}
+function decideTenantAction(tenantDbExists, adminUserExists) {
+	if (tenantDbExists && adminUserExists) return "already-provisioned";
+	if (tenantDbExists) return "reset-and-seed";
+	return "create-and-seed";
+}
+function parseMysqlUrl(url) {
+	const u = new URL(url);
+	return {
+		host: u.hostname || "localhost",
+		port: u.port || "3306",
+		user: decodeURIComponent(u.username) || "root",
+		password: u.password ? decodeURIComponent(u.password) : void 0
+	};
+}
+function dbNameFromUrl(url) {
+	return new URL(url).pathname.replace(/^\//, "");
+}
+function swapDbName(url, name) {
+	const u = new URL(url);
+	u.pathname = `/${name}`;
+	return u.toString();
+}
+function mysqlArgs(conn) {
+	const args = [
+		"-h",
+		conn.host,
+		"-P",
+		conn.port,
+		"-u",
+		conn.user
+	];
+	if (conn.password) args.push(`-p${conn.password}`);
+	return args;
+}
+function mysqlQuery(conn, sql) {
+	return capture("mysql", [
+		...mysqlArgs(conn),
+		"-N",
+		"-B",
+		"-e",
+		sql
+	]);
+}
+function mysqlExec(conn, sql) {
+	return run("mysql", [
+		...mysqlArgs(conn),
+		"-e",
+		sql
+	]);
+}
+function dbExists(conn, name) {
+	const { out } = mysqlQuery(conn, `SELECT SCHEMA_NAME FROM information_schema.SCHEMATA WHERE SCHEMA_NAME = '${name}'`);
+	return out.length > 0;
+}
+function tableExists(conn, db, table) {
+	const { out } = mysqlQuery(conn, `SELECT TABLE_NAME FROM information_schema.TABLES WHERE TABLE_SCHEMA = '${db}' AND TABLE_NAME = '${table}'`);
+	return out.length > 0;
+}
+function adminUserExists(conn, db, email) {
+	if (!tableExists(conn, db, "User")) return false;
+	const { ok, out } = mysqlQuery(conn, `SELECT COUNT(*) FROM \`${db}\`.\`User\` WHERE email = '${email}'`);
+	return ok && parseInt(out, 10) > 0;
+}
+function migrateDeploy(serverPath, url) {
+	return run("npx", [
+		"prisma",
+		"migrate",
+		"deploy"
+	], serverPath, { DATABASE_URL: url });
+}
+function runDisposableScript(serverPath, fileName, contents, env, extraArgs = []) {
+	const scriptPath = join(serverPath, fileName);
+	writeFileSync(scriptPath, contents, "utf-8");
+	try {
+		return run("npx", [
+			"ts-node",
+			"--transpile-only",
+			"-r",
+			"tsconfig-paths/register",
+			scriptPath,
+			...extraArgs
+		], serverPath, env);
+	} finally {
+		rmSync(scriptPath, { force: true });
+	}
+}
+function setupLocalDatabase(serverPath, env) {
+	const controlPlaneUrl = env.DATABASE_URL;
+	const clientId = env.CLIENT_ID;
+	const adminPassword = env.ADMIN_PASSWORD;
+	if (!controlPlaneUrl || !clientId || !adminPassword) {
+		M.warn("local.env is missing DATABASE_URL / CLIENT_ID / ADMIN_PASSWORD — skipping database setup.");
+		return;
+	}
+	const conn = parseMysqlUrl(controlPlaneUrl);
+	const controlPlaneName = dbNameFromUrl(controlPlaneUrl);
+	const tenantName = `tenant-${clientId}`;
+	const tenantUrl = swapDbName(controlPlaneUrl, tenantName);
+	const adminEmail = `admin@${clientId}.com`;
+	M.step(`Setting up local databases (${controlPlaneName} + ${tenantName})…`);
+	mysqlExec(conn, `CREATE DATABASE IF NOT EXISTS \`${controlPlaneName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
+	if (!migrateDeploy(serverPath, controlPlaneUrl)) {
+		M.warn("Control-plane migration failed — skipping the rest of database setup.");
+		return;
+	}
+	runDisposableScript(serverPath, ".pruff-onboarding-preseed.ts", CONTROL_PLANE_PRESEED_SCRIPT, {
+		...env,
+		DATABASE_URL: controlPlaneUrl
+	});
+	const action = decideTenantAction(dbExists(conn, tenantName), adminUserExists(conn, tenantName, adminEmail));
+	if (action === "already-provisioned") {
+		M.success(`Tenant "${clientId}" already provisioned — skipping seed.`);
+		printLoginHint(clientId, adminEmail, adminPassword);
+		return;
+	}
+	if (action === "reset-and-seed") {
+		M.warn(`Tenant "${clientId}" partially provisioned — resetting (Pruff-server seed is not idempotent).`);
+		mysqlExec(conn, `DROP DATABASE IF EXISTS \`${tenantName}\``);
+	}
+	mysqlExec(conn, `CREATE DATABASE IF NOT EXISTS \`${tenantName}\` CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci`);
+	if (!migrateDeploy(serverPath, tenantUrl)) {
+		M.warn("Tenant migration failed — skipping seed.");
+		return;
+	}
+	const s = Y();
+	s.start(`Seeding tenant "${clientId}"…`);
+	const seeded = run("npx", [
+		"prisma",
+		"db",
+		"seed"
+	], serverPath, {
+		...env,
+		DATABASE_URL: tenantUrl
+	});
+	s.stop(seeded ? `Tenant "${clientId}" seeded` : import_picocolors.default.yellow("Tenant seed failed"));
+	if (!seeded) return;
+	if (!runDisposableScript(serverPath, ".pruff-onboarding-tenant-user.ts", TENANT_USER_BACKFILL_SCRIPT, {
+		...env,
+		DATABASE_URL: tenantUrl
+	}, [adminEmail, adminPassword])) {
+		M.warn("Tenant admin-user backfill failed — you may need to create the user manually.");
+		return;
+	}
+	M.success(`Local tenant "${clientId}" ready.`);
+	printLoginHint(clientId, adminEmail, adminPassword);
+}
+function printLoginHint(clientId, email, password) {
+	M.info(`Log in locally with:\n  ${import_picocolors.default.dim("secretId:")} ${import_picocolors.default.cyan(clientId)}\n  ${import_picocolors.default.dim("email:   ")} ${import_picocolors.default.cyan(email)}\n  ${import_picocolors.default.dim("password:")} ${import_picocolors.default.cyan(password)}`);
+}
 async function showGuidance(workspace) {
 	console.log();
 	await sweepLine("W O R K S P A C E   R E A D Y", { slow: true });
@@ -6311,10 +7181,11 @@ async function showGuidance(workspace) {
 	line("");
 	line(`${import_picocolors.default.cyan(workspace)}/`);
 	const tree = [
+		["CLAUDE.md", "workspace-level context — repo map, conventions, critical rules"],
 		[".claude/", "rules · agents · skills (apply to every repo below)"],
 		[`${KNOWLEDGE_DIR}/`, "Obsidian vault — open it in Obsidian"],
-		["Pruff-server/", "backend"],
-		["Pruff-Client/", "frontend"],
+		["Pruff-server/", "backend (bun)"],
+		["Pruff-Client/", "frontend (yarn)"],
 		["sls-*/", "serverless services — clone as you need them"]
 	];
 	const labelWidth = Math.max(...tree.map(([label]) => label.length)) + 2;
@@ -6326,9 +7197,8 @@ async function showGuidance(workspace) {
 	line(import_picocolors.default.bold("Next steps"));
 	line(`${import_picocolors.default.dim("1.")} Open ${import_picocolors.default.bold("Obsidian")} → the ${import_picocolors.default.cyan(KNOWLEDGE_DIR)} vault is registered and ready.`);
 	line(`${import_picocolors.default.dim("2.")} Start Claude Code from ${import_picocolors.default.cyan(workspace)} so the shared ${import_picocolors.default.dim(".claude/")} applies everywhere.`);
-	line(`${import_picocolors.default.dim("3.")} Backend:  ${import_picocolors.default.dim("cd Pruff-server && npm i && npm run local")}`);
-	line(`${import_picocolors.default.dim("4.")} Frontend: ${import_picocolors.default.dim("cd Pruff-Client && yarn && yarn start-local")}`);
-	line(`${import_picocolors.default.dim("5.")} Clone any serverless service into this folder with ${import_picocolors.default.dim("git clone <repo>")}.`);
+	line(`${import_picocolors.default.dim("3.")} Dependencies are installed — ${import_picocolors.default.dim("cd Pruff-server && npm run local")} / ${import_picocolors.default.dim("cd Pruff-Client && yarn start-local")}.`);
+	line(`${import_picocolors.default.dim("4.")} Clone any serverless service into this folder with ${import_picocolors.default.dim("git clone <repo>")}.`);
 	console.log();
 }
 function registerVault(vaultPath) {
@@ -6356,6 +7226,405 @@ function registerVault(vaultPath) {
 	writeFileSync(configPath, JSON.stringify(config), "utf-8");
 	M.success("Registered vault in Obsidian");
 }
+const execFileAsync = promisify(execFile);
+const BUZZ_LOGO_LINES = [
+	"██████╗ ██╗   ██╗███████╗███████╗",
+	"██╔══██╗██║   ██║╚══███╔╝╚══███╔╝",
+	"██████╔╝██║   ██║  ███╔╝   ███╔╝ ",
+	"██╔══██╗██║   ██║ ███╔╝   ███╔╝  ",
+	"██████╔╝╚██████╔╝███████╗███████╗",
+	"╚═════╝  ╚═════╝ ╚══════╝╚══════╝"
+];
+const BUZZ_LETTER_CUTS = [
+	8,
+	17,
+	25,
+	33
+];
+async function showBuzzLogo() {
+	await showBlockLogo(BUZZ_LOGO_LINES, BUZZ_LETTER_CUTS);
+}
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+const nestDir = () => process.env.BUZZ_NEST_DIR?.trim() || join(homedir(), ".buzz");
+function buzzAppDataDir() {
+	if (process.env.BUZZ_APP_DATA_DIR?.trim()) return process.env.BUZZ_APP_DATA_DIR.trim();
+	const home = homedir();
+	switch (platform()) {
+		case "darwin": return join(home, "Library", "Application Support", "xyz.block.buzz.app");
+		case "win32": return join(process.env.APPDATA || join(home, "AppData", "Roaming"), "xyz.block.buzz.app");
+		default: return join(process.env.XDG_DATA_HOME || join(home, ".local", "share"), "xyz.block.buzz.app");
+	}
+}
+const agentStorePath = () => join(buzzAppDataDir(), "agents", "managed-agents.json");
+const packsRoot = () => process.env.BUZZ_PACKS_DIR?.trim() || join(__dirname$1, "..", "packs");
+const VAULT_REPO = "https://github.com/Pruff-Tech/pruff-knowledge.git";
+const SKILLS_COMMON = [
+	"commit",
+	"create-pr",
+	"handoff",
+	"linear",
+	"using-git-worktrees",
+	"pruff-knowledge"
+];
+const TEAM_SKILLS = {
+	platform: [
+		"prod-parity",
+		"pruff-logs",
+		"infra-healthcheck",
+		"prisma-cli",
+		"pruff-pr-review",
+		"review-pr-comments",
+		"logging-sweep"
+	],
+	core: [
+		"pruff-logs",
+		"pruff-pr-review",
+		"review-pr-comments",
+		"logging-sweep",
+		"prisma-cli"
+	],
+	growth: [
+		"tanstack-migrate",
+		"react-doctor",
+		"pr-visualizer",
+		"pruff-pr-review"
+	]
+};
+const TEAM_AGENTS = {
+	platform: [
+		"codebase-navigator",
+		"db-query-reviewer",
+		"pruff-logs-investigator",
+		"implementer"
+	],
+	core: [
+		"codebase-navigator",
+		"pruff-logs-investigator",
+		"implementer"
+	],
+	growth: ["codebase-navigator", "implementer"]
+};
+const TEAMS = Object.keys(TEAM_SKILLS);
+async function isBuzzRunning() {
+	try {
+		const { stdout } = await execFileAsync("pgrep", ["-f", "Buzz.app|buzz-desktop|buzz-acp"]);
+		return stdout.trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function claudeAuthStatus() {
+	try {
+		const { stdout } = await execFileAsync("claude", ["auth", "status"]);
+		const parsed = JSON.parse(stdout);
+		const ok = parsed.apiProvider === "firstParty";
+		return {
+			ok,
+			detail: ok ? parsed.subscriptionType ?? "subscription" : JSON.stringify(parsed)
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			detail: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+async function checkPreconditions() {
+	M.step("Checking preconditions");
+	if (await isBuzzRunning()) {
+		M.error("Buzz is running. Quit it first — it owns the agent store and would overwrite this.");
+		process.exit(1);
+	}
+	M.success("Buzz is not running");
+	const auth = await claudeAuthStatus();
+	if (!auth.ok) {
+		M.error("Claude is not on a subscription login. Run: claude auth login --claudeai");
+		M.message(import_picocolors.default.dim(auth.detail));
+		process.exit(1);
+	}
+	M.success(`Claude on subscription (${auth.detail})`);
+	if (process.env.ANTHROPIC_API_KEY) {
+		M.error("ANTHROPIC_API_KEY is set — this routes billing to the API instead of your seat. Unset it.");
+		process.exit(1);
+	}
+	M.success("No ANTHROPIC_API_KEY in the environment");
+	if (!existsSync(nestDir())) {
+		M.error(`No nest at ${nestDir()}. Launch Buzz once to create it, then quit and re-run.`);
+		process.exit(1);
+	}
+	M.success("Nest exists");
+}
+async function syncVault() {
+	M.step("Pruff knowledge vault");
+	const dest = join(nestDir(), "REPOS", "pruff-knowledge");
+	if (existsSync(join(dest, ".git"))) try {
+		await execFileAsync("git", [
+			"-C",
+			dest,
+			"pull",
+			"--ff-only",
+			"--quiet"
+		]);
+		const { stdout } = await execFileAsync("git", [
+			"-C",
+			dest,
+			"log",
+			"-1",
+			"--format=%h %ad",
+			"--date=short"
+		]);
+		M.success(`updated → ${stdout.trim()}`);
+	} catch {
+		M.error(`pull failed — the clone has diverged (something committed there). Delete it and re-run: rm -rf "${dest}"`);
+		process.exit(1);
+	}
+	else {
+		mkdirSync(dirname(dest), { recursive: true });
+		try {
+			await execFileAsync("git", [
+				"clone",
+				"--quiet",
+				VAULT_REPO,
+				dest
+			]);
+			const { stdout } = await execFileAsync("git", [
+				"-C",
+				dest,
+				"log",
+				"-1",
+				"--format=%h %ad",
+				"--date=short"
+			]);
+			M.success(`cloned → ${stdout.trim()}`);
+		} catch {
+			M.error("clone failed — do you have read access to Pruff-Tech/pruff-knowledge?");
+			process.exit(1);
+		}
+	}
+}
+async function installSkillsAndAgents(team) {
+	M.step("Skills and subagents (installed into the nest, which is the agents' cwd)");
+	const skills = [...SKILLS_COMMON, ...TEAM_SKILLS[team] ?? []];
+	const subagents = TEAM_AGENTS[team] ?? [];
+	const priorCwd = process.cwd();
+	process.chdir(nestDir());
+	try {
+		for (const skill of skills) {
+			if (existsSync(join(nestDir(), ".claude", "skills", skill))) {
+				M.success(`${skill} (already present)`);
+				continue;
+			}
+			try {
+				const { source, options } = parseAddOptions([skill, "-y"]);
+				await runAdd(source, options);
+				M.success(skill);
+			} catch {
+				M.warn(`${import_picocolors.default.yellow(skill)} — not found in the catalog, skipped`);
+			}
+		}
+		for (const agent of subagents) {
+			if (existsSync(join(nestDir(), ".claude", "agents", `${agent}.md`))) {
+				M.success(`subagent ${agent} (already present)`);
+				continue;
+			}
+			try {
+				await addAgents([agent], { yes: true });
+			} catch {
+				M.warn(`subagent ${import_picocolors.default.yellow(agent)} — not found, skipped`);
+			}
+		}
+	} finally {
+		process.chdir(priorCwd);
+	}
+}
+const BASE_BUILTIN = {
+	bumble: "builtin:bumble",
+	honey: "builtin:honey",
+	fizz: "builtin:fizz"
+};
+function roleOf(name) {
+	return Object.keys(BASE_BUILTIN).find((role) => name.startsWith(role)) ?? "bumble";
+}
+async function composePersonaPrompt(packDir, personaFile, shared) {
+	return `${(await readFile(join(packDir, personaFile), "utf8")).replace(/^---\n[\s\S]*?\n---\n/, "").trim()}\n\n---\n\n${shared}`;
+}
+async function seedPersonas(team) {
+	M.step("Seeding persona definitions into Buzz's agent store");
+	const packDir = join(packsRoot(), `pruff-${team}`);
+	if (!existsSync(packDir)) {
+		M.error(`No pack bundled for team "${team}" at ${packDir}.`);
+		M.message(import_picocolors.default.dim(`Available: ${TEAMS.join(", ")}`));
+		process.exit(1);
+	}
+	const store = agentStorePath();
+	if (!existsSync(store)) {
+		M.error(`No agent store at ${store}. Launch Buzz once, quit, then re-run.`);
+		process.exit(1);
+	}
+	const backup = `${store}.backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+	copyFileSync(store, backup);
+	M.success(`backup → ${backup}`);
+	const shared = (await readFile(join(packDir, "instructions.md"), "utf8")).trim();
+	const personaFiles = JSON.parse(await readFile(join(packDir, ".plugin", "plugin.json"), "utf8")).personas;
+	const records = JSON.parse(readFileSync(store, "utf8"));
+	const builtins = {};
+	for (const r of records) if (!r.pubkey && r.slug) builtins[r.slug] = r;
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	let added = 0;
+	let updated = 0;
+	for (const file of personaFiles) {
+		const nameMatch = ((await readFile(join(packDir, file), "utf8")).match(/^---\n([\s\S]*?)\n---\n/)?.[1] ?? "").match(/^name:\s*"?([^"\n]+)"?/m);
+		if (!nameMatch) {
+			M.warn(`${file} has no name: in frontmatter, skipped`);
+			continue;
+		}
+		const name = nameMatch[1].trim();
+		const slug = `pruff:${name}`;
+		const prompt = await composePersonaPrompt(packDir, file, shared);
+		const base = builtins[BASE_BUILTIN[roleOf(name)]];
+		const existing = records.find((r) => r.slug === slug);
+		if (existing) {
+			existing.system_prompt = prompt;
+			existing.updated_at = now;
+			updated++;
+		} else if (base) {
+			records.push({
+				...base,
+				name,
+				display_name: name,
+				name_pool: [name],
+				slug,
+				is_builtin: false,
+				is_active: true,
+				system_prompt: prompt,
+				parallelism: 4,
+				persona_id: null,
+				persona_source_version: null,
+				created_at: now,
+				updated_at: now
+			});
+			added++;
+		} else {
+			M.warn(`No builtin base found for "${name}" (role guessed: ${roleOf(name)}), skipped`);
+			continue;
+		}
+		for (const r of records) if (r.pubkey && r.persona_id === slug) {
+			r.system_prompt = prompt;
+			r.updated_at = now;
+		}
+	}
+	writeFileSync(store, JSON.stringify(records, null, 2), "utf8");
+	M.success(`${added} persona(s) added, ${updated} updated`);
+}
+async function runSetup(team) {
+	if (!team || !TEAMS.includes(team)) {
+		M.error(`usage: pruff-skills buzz setup <${TEAMS.join("|")}>`);
+		process.exit(1);
+	}
+	if (!existsSync(join(packsRoot(), `pruff-${team}`))) {
+		M.error(`No pack bundled yet for "${team}". Run ${import_picocolors.default.cyan(`pruff-skills buzz packs init ${team}`)} first, write its personas, then re-run setup.`);
+		process.exit(1);
+	}
+	Ie(import_picocolors.default.cyan(`pruff-skills buzz setup ${team}`));
+	await checkPreconditions();
+	await syncVault();
+	await installSkillsAndAgents(team);
+	await seedPersonas(team);
+	Se([
+		import_picocolors.default.bold("Remaining steps are in the Buzz app:"),
+		"",
+		"  1. Open Buzz.",
+		"  2. Settings → Agents → Add agent, for each role:",
+		"       • runtime:  Claude Code",
+		`       • persona:  pick the pruff:* persona seeded above`,
+		`       • name:     <role>-${team}-<your initials>   e.g. bumble-${team}-ab`,
+		"       • login:    Claude Subscription  (NOT Anthropic Console)",
+		"       • Start on app launch: ON",
+		"  3. Post your 64-char hex pubkey wherever your team collects them.",
+		"  4. Test it: ask your bumble \"¿cómo maneja Pruff el multi-tenancy?\" —",
+		"     a cited answer (architecture/multi-tenancy.md) means it worked.",
+		"",
+		"  This cannot be scripted further: an agent identity carries an owner",
+		"  attestation only the Buzz app can mint."
+	].join("\n"));
+}
+async function runSync(team) {
+	if (!team || !TEAMS.includes(team)) {
+		M.error(`usage: pruff-skills buzz sync <${TEAMS.join("|")}>`);
+		M.message(import_picocolors.default.dim("Re-pushes persona prompts after you edit a pack — no vault pull, no skill install."));
+		process.exit(1);
+	}
+	Ie(import_picocolors.default.cyan(`pruff-skills buzz sync ${team}`));
+	await checkPreconditions();
+	await seedPersonas(team);
+	Se("Quit and relaunch Buzz is not needed — Buzz reads the store fresh on next start of that agent.");
+}
+function runPacksList() {
+	console.log(import_picocolors.default.bold("Bundled packs:"));
+	for (const team of TEAMS) {
+		const dir = join(packsRoot(), `pruff-${team}`);
+		console.log(`  ${existsSync(dir) ? import_picocolors.default.green("✓") : import_picocolors.default.red("✗")} ${team}  ${import_picocolors.default.dim(dir)}`);
+	}
+}
+function runPacksInit(team) {
+	if (!team) {
+		M.error("usage: pruff-skills buzz packs init <team>");
+		process.exit(1);
+	}
+	const src = join(packsRoot(), "pruff-platform");
+	const dest = join(packsRoot(), `pruff-${team}`);
+	if (existsSync(dest)) {
+		M.error(`packs/pruff-${team} already exists.`);
+		process.exit(1);
+	}
+	cpSync(src, dest, { recursive: true });
+	M.success(`Scaffolded packs/pruff-${team} from pruff-platform. Edit the personas, then add "${team}" support in src/buzz.ts's TEAM_SKILLS / TEAM_AGENTS.`);
+}
+const BUZZ_HELP = `${import_picocolors.default.bold("Usage:")} pruff-skills buzz <command> [options]
+
+Set up a Buzz (github.com/block/buzz) agent nest with the Pruff harness — the
+knowledge vault, team skills and subagents, and persona definitions. Buzz agents
+run from ~/.buzz, a different working directory than any code checkout, so
+nothing installed elsewhere is visible to them until it's installed here too.
+
+${import_picocolors.default.bold("Commands:")}
+  setup <team>       Full setup for one team's agents: platform | core | growth
+  sync <team>        Re-push persona prompts after editing a pack (no vault/skill work)
+  packs list         Show which team packs are bundled
+  packs init <team>  Scaffold a new team pack from pruff-platform
+
+${import_picocolors.default.bold("Examples:")}
+  pruff-skills buzz setup platform
+  pruff-skills buzz sync platform
+  pruff-skills buzz packs list
+
+Quit Buzz before running setup or sync — it owns the agent store while running.
+Creating the actual agents happens in the Buzz app; this command prepares
+everything up to that point.`;
+async function runBuzz(args) {
+	const sub = args[0];
+	const rest = args.slice(1);
+	if (!sub || sub === "--help" || sub === "-h") {
+		console.log(BUZZ_HELP);
+		return;
+	}
+	switch (sub) {
+		case "setup":
+			await runSetup(rest[0]);
+			return;
+		case "sync":
+			await runSync(rest[0]);
+			return;
+		case "packs":
+			if (rest[0] === "list") return runPacksList();
+			if (rest[0] === "init") return runPacksInit(rest[1]);
+			console.log(BUZZ_HELP);
+			return;
+		default:
+			console.log(`Unknown buzz command: ${sub}`);
+			console.log(BUZZ_HELP);
+	}
+}
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
 	try {
@@ -6377,11 +7646,6 @@ const LOGO_LINES = [
 	"██║     ██║  ██║╚██████╔╝██║     ██║     ",
 	"╚═╝     ╚═╝  ╚═╝ ╚═════╝ ╚═╝     ╚═╝     "
 ];
-function printStaticLogo() {
-	LOGO_LINES.forEach((line, i) => {
-		console.log(`${BLUES[i]}${line}${RESET}`);
-	});
-}
 const LETTER_CUTS = [
 	8,
 	16,
@@ -6389,116 +7653,71 @@ const LETTER_CUTS = [
 	33,
 	41
 ];
-function renderLogoReveal(cut, width) {
-	return LOGO_LINES.map((line, i) => {
-		const shown = Array.from(line).slice(0, cut);
-		const pad = " ".repeat(Math.max(0, width - shown.length));
-		return `${BLUES[i]}${shown.join("")}${RESET}${pad}`;
-	}).join("\n");
-}
-function renderLogoFrame(pos, band) {
-	return LOGO_LINES.map((line, i) => {
-		const chars = Array.from(line);
-		let out = "";
-		let mode = "";
-		for (let c = 0; c < chars.length; c++) {
-			const color = c >= pos && c < pos + band ? SWEEP : BLUES[i];
-			if (color !== mode) {
-				out += color;
-				mode = color;
-			}
-			out += chars[c];
-		}
-		return out + RESET;
-	}).join("\n");
-}
 async function showLogo(slow = false) {
-	console.log();
-	if (!(!!process.stdout.isTTY && !process.env.CI && !process.env.NO_COLOR && !process.env.PRUFF_SKILLS_NO_ANIM)) {
-		printStaticLogo();
-		return;
-	}
-	const rows = LOGO_LINES.length;
-	const width = Math.max(...LOGO_LINES.map((l) => Array.from(l).length));
-	const band = 7;
-	const revealMs = slow ? 190 : 90;
-	const step = slow ? 3 : 4;
-	const sweepMs = slow ? 34 : 18;
-	process.stdout.write("\x1B[?25l");
-	try {
-		let first = true;
-		for (const cut of LETTER_CUTS) {
-			if (!first) process.stdout.write(`\x1b[${rows}A`);
-			process.stdout.write("\r" + renderLogoReveal(cut, width) + "\n");
-			first = false;
-			await sleep(revealMs);
-		}
-		for (let pos = -7; pos <= width; pos += step) {
-			process.stdout.write(`\x1b[${rows}A`);
-			process.stdout.write("\r" + renderLogoFrame(pos, band) + "\n");
-			await sleep(sweepMs);
-		}
-		process.stdout.write(`\x1b[${rows}A\r`);
-		process.stdout.write(LOGO_LINES.map((line, i) => `${BLUES[i]}${line}${RESET}`).join("\n") + "\n");
-		if (slow) await sleep(500);
-	} finally {
-		process.stdout.write("\x1B[?25h");
-	}
+	await showBlockLogo(LOGO_LINES, LETTER_CUTS, { slow });
 }
-const TAGLINE_BLOCKS = [[
+const BUILDING_LINES = [
 	"██████╗ ██╗   ██╗██╗██╗     ██████╗ ██╗███╗   ██╗ ██████╗ ",
 	"██╔══██╗██║   ██║██║██║     ██╔══██╗██║████╗  ██║██╔════╝ ",
 	"██████╔╝██║   ██║██║██║     ██║  ██║██║██╔██╗ ██║██║  ███╗",
 	"██╔══██╗██║   ██║██║██║     ██║  ██║██║██║╚██╗██║██║   ██║",
 	"██████╔╝╚██████╔╝██║███████╗██████╔╝██║██║ ╚████║╚██████╔╝",
 	"╚═════╝  ╚═════╝ ╚═╝╚══════╝╚═════╝ ╚═╝╚═╝  ╚═══╝ ╚═════╝ "
-], [
+];
+const FINTECHS_LINES = [
 	"███████╗██╗███╗   ██╗████████╗███████╗ ██████╗██╗  ██╗███████╗",
 	"██╔════╝██║████╗  ██║╚══██╔══╝██╔════╝██╔════╝██║  ██║██╔════╝",
 	"█████╗  ██║██╔██╗ ██║   ██║   █████╗  ██║     ███████║███████╗",
 	"██╔══╝  ██║██║╚██╗██║   ██║   ██╔══╝  ██║     ██╔══██║╚════██║",
 	"██║     ██║██║ ╚████║   ██║   ███████╗╚██████╗██║  ██║███████║",
 	"╚═╝     ╚═╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝"
-]];
-const TAGLINE_INDENT = "  ";
-function renderTaglineRow(line, row, pos, band) {
+];
+const TAGLINE_INDENT = "";
+const TAGLINE_ROWS = BUILDING_LINES.length + FINTECHS_LINES.length;
+const WHITES = [
+	"\x1B[38;2;255;255;255m",
+	"\x1B[38;2;228;230;236m",
+	"\x1B[38;2;201;205;216m",
+	"\x1B[38;2;174;180;196m",
+	"\x1B[38;2;148;155;176m",
+	"\x1B[38;2;122;131;156m"
+];
+function renderRevealRow(line, row, cols, fromLeft) {
 	const chars = Array.from(line);
-	let out = TAGLINE_INDENT;
-	let mode = "";
-	for (let c = 0; c < chars.length; c++) {
-		const color = c >= pos && c < pos + band ? SWEEP : BLUES[row];
-		if (color !== mode) {
-			out += color;
-			mode = color;
-		}
-		out += chars[c];
+	const w = chars.length;
+	let out = TAGLINE_INDENT + WHITES[Math.min(WHITES.length - 1, row)];
+	for (let c = 0; c < w; c++) {
+		const shown = fromLeft ? c < cols : c >= w - cols;
+		out += shown ? chars[c] : " ";
 	}
 	return out + RESET;
 }
-function renderTaglineFrame(pos, band) {
-	return TAGLINE_BLOCKS.map((block) => block.map((line, row) => renderTaglineRow(line, row, pos, band)).join("\n")).join("\n");
+function renderTaglineReveal(cols) {
+	const rows = [];
+	BUILDING_LINES.forEach((line, row) => rows.push(renderRevealRow(line, row, cols, true)));
+	FINTECHS_LINES.forEach((line, row) => rows.push(renderRevealRow(line, row, cols, false)));
+	return rows.join("\n");
 }
 async function showTagline(slow = false) {
 	console.log();
-	const rows = TAGLINE_BLOCKS.reduce((n, b) => n + b.length, 0);
-	const width = Math.max(...TAGLINE_BLOCKS.flat().map((l) => Array.from(l).length));
-	const band = 7;
-	const step = slow ? 3 : 4;
-	const sweepMs = slow ? 34 : 18;
+	const rows = TAGLINE_ROWS;
+	const width = Math.max(...[...BUILDING_LINES, ...FINTECHS_LINES].map((l) => Array.from(l).length));
+	const step = slow ? 2 : 3;
+	const ms = slow ? 26 : 14;
 	if (!(!!process.stdout.isTTY && !process.env.CI && !process.env.NO_COLOR && !process.env.PRUFF_SKILLS_NO_ANIM)) {
-		console.log(renderTaglineFrame(-1, 0));
+		console.log(renderTaglineReveal(width));
 		return;
 	}
 	process.stdout.write("\x1B[?25l");
 	try {
 		let first = true;
-		for (let pos = -7; pos <= width; pos += step) {
+		for (let cols = 0; cols <= width; cols += step) {
 			if (!first) process.stdout.write(`\x1b[${rows}A`);
-			process.stdout.write("\r" + renderTaglineFrame(pos, band) + "\n");
+			process.stdout.write("\r" + renderTaglineReveal(cols) + "\n");
 			first = false;
-			await sleep(sweepMs);
+			await sleep(ms);
 		}
-		process.stdout.write(`\x1b[${rows}A\r` + renderTaglineFrame(-1, 0) + "\n");
+		process.stdout.write(`\x1b[${rows}A\r` + renderTaglineReveal(width) + "\n");
 		if (slow) await sleep(500);
 	} finally {
 		process.stdout.write("\x1B[?25h");
@@ -6757,6 +7976,10 @@ async function main() {
 			if (!inAgent) await showLogo();
 			await runRules(restArgs);
 			break;
+		case "buzz":
+			if (!inAgent) await showBuzzLogo();
+			await runBuzz(restArgs);
+			break;
 		case "onboarding":
 		case "onboard":
 			if (!inAgent) {
@@ -6778,7 +8001,7 @@ async function main() {
 		case "experimental_sync": {
 			if (!inAgent) await showLogo();
 			const { options: syncOptions } = parseSyncOptions(restArgs);
-			await runSync(restArgs, syncOptions);
+			await runSync$1(restArgs, syncOptions);
 			break;
 		}
 		case "list":