thevoidforge 21.0.0

package/dist/wizard/lib/codegen/seed-gen.js

@@ -0,0 +1,128 @@
+/**
+ * Database seeding script generation (ADR-025).
+ * Generates seed.ts with factory functions for all Prisma models.
+ * Conditional — only runs if prisma/schema.prisma exists.
+ */
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+/** Map Prisma types to TypeScript factory values. */
+const FACTORY_VALUES = {
+    'String': "'Test value'",
+    'Int': '1',
+    'Float': '1.0',
+    'Boolean': 'true',
+    'DateTime': 'new Date()',
+    'Json': '{}',
+    'BigInt': 'BigInt(1)',
+    'Decimal': '1.0',
+};
+function parseSeedModels(content) {
+    const models = [];
+    const modelRegex = /model\s+(\w+)\s*\{([^}]+)\}/g;
+    let match;
+    while ((match = modelRegex.exec(content)) !== null) {
+        const name = match[1];
+        const body = match[2];
+        const fields = [];
+        const builtinTypes = ['String', 'Int', 'Float', 'Boolean', 'DateTime', 'Json', 'BigInt', 'Decimal', 'Bytes'];
+        for (const line of body.split('\n')) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('//') || trimmed.startsWith('@@'))
+                continue;
+            const fieldMatch = trimmed.match(/^(\w+)\s+(\w+)(\[\])?\s*(\?)?\s*(.*)/);
+            if (fieldMatch) {
+                const fieldName = fieldMatch[1];
+                const fieldType = fieldMatch[2];
+                const isOptional = !!fieldMatch[4];
+                const rest = fieldMatch[5] || '';
+                const hasDefault = rest.includes('@default');
+                const isId = rest.includes('@id');
+                const isRelation = !builtinTypes.includes(fieldType);
+                if (!isRelation && !fieldMatch[3]) { // Skip arrays (relations)
+                    fields.push({ name: fieldName, type: fieldType, isOptional, hasDefault, isId, isRelation });
+                }
+            }
+        }
+        models.push({ name, fields });
+    }
+    return models;
+}
+function buildSeedContent(models) {
+    const factories = [];
+    const seedCalls = [];
+    for (const model of models) {
+        const lowerName = model.name.charAt(0).toLowerCase() + model.name.slice(1);
+        const factoryFields = model.fields
+            .filter(f => !f.isId && !f.hasDefault && !f.isOptional)
+            .map(f => `    ${f.name}: ${FACTORY_VALUES[f.type] || "'TODO'"},`)
+            .join('\n');
+        factories.push(`function create${model.name}(overrides: Partial<Prisma.${model.name}CreateInput> = {}): Prisma.${model.name}CreateInput {
+  return {
+${factoryFields}
+    ...overrides,
+  };
+}`);
+        seedCalls.push(`  // ${model.name}
+  const ${lowerName} = await prisma.${lowerName}.create({ data: create${model.name}() });
+  console.log('Created ${model.name}:', ${lowerName}.id ?? '(no id)');`);
+    }
+    return `// Database seed script — generated by VoidForge (ADR-025)
+// Run: npx tsx prisma/seed.ts
+// Or: npm run seed (add "seed": "npx tsx prisma/seed.ts" to package.json scripts)
+
+import { PrismaClient, Prisma } from '@prisma/client';
+
+const prisma = new PrismaClient();
+
+// ── Factory Functions ────────────────────────────────────
+
+${factories.join('\n\n')}
+
+// ── Seed ─────────────────────────────────────────────────
+
+async function seed() {
+  console.log('Seeding database...');
+
+${seedCalls.join('\n\n')}
+
+  console.log('Seeding complete.');
+}
+
+seed()
+  .catch((e) => {
+    console.error('Seed failed:', e);
+    process.exit(1);
+  })
+  .finally(() => prisma.$disconnect());
+`;
+}
+/**
+ * Generate a database seed script from the Prisma schema.
+ */
+export async function generateSeedScript(projectDir, emit) {
+    const schemaPath = join(projectDir, 'prisma', 'schema.prisma');
+    if (!existsSync(schemaPath)) {
+        emit({ step: 'seed', status: 'skipped', message: 'No prisma/schema.prisma found — seed generation skipped' });
+        return { success: true, file: '', modelCount: 0 };
+    }
+    emit({ step: 'seed', status: 'started', message: 'Generating database seed script' });
+    try {
+        const schema = await readFile(schemaPath, 'utf-8');
+        const models = parseSeedModels(schema);
+        if (models.length === 0) {
+            emit({ step: 'seed', status: 'skipped', message: 'No models found in Prisma schema' });
+            return { success: true, file: '', modelCount: 0 };
+        }
+        const prismaDir = join(projectDir, 'prisma');
+        await mkdir(prismaDir, { recursive: true });
+        const script = buildSeedContent(models);
+        await writeFile(join(prismaDir, 'seed.ts'), script, 'utf-8');
+        emit({ step: 'seed', status: 'done', message: `Generated prisma/seed.ts — ${models.length} model factories. Run: npx tsx prisma/seed.ts` });
+        return { success: true, file: 'prisma/seed.ts', modelCount: models.length };
+    }
+    catch (err) {
+        emit({ step: 'seed', status: 'error', message: 'Failed to generate seed script', detail: err.message });
+        return { success: false, file: '', modelCount: 0, error: err.message };
+    }
+}

package/dist/wizard/lib/compliance.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Szeth's Compliance Framework — Campaign compliance checks (§9.12).
+ *
+ * Every campaign is audited before launch. Critical compliance issues block launch.
+ * Covers: privacy (GDPR, cookie consent), email (CAN-SPAM), ad platform ToS,
+ * and financial reporting requirements.
+ *
+ * PRD Reference: §9.12 (Compliance Framework), §9.3 Phase 5
+ */
+type AdPlatform = 'meta' | 'google' | 'tiktok' | 'linkedin' | 'twitter' | 'reddit';
+type ComplianceSeverity = 'critical' | 'high' | 'medium' | 'low';
+type ComplianceCategory = 'privacy' | 'email' | 'platform_tos' | 'financial';
+interface ComplianceFinding {
+    id: string;
+    category: ComplianceCategory;
+    severity: ComplianceSeverity;
+    title: string;
+    description: string;
+    remediation: string;
+    platform?: AdPlatform;
+    blocking: boolean;
+}
+interface ComplianceReport {
+    projectId: string;
+    timestamp: string;
+    findings: ComplianceFinding[];
+    passed: boolean;
+    summary: {
+        critical: number;
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+interface CreativeContent {
+    headlines: string[];
+    descriptions: string[];
+    landingUrl: string;
+}
+export declare function runComplianceAudit(projectId: string, options: {
+    hasTracking: boolean;
+    targetsEU: boolean;
+    hasOutreach: boolean;
+    hasUnsubscribe: boolean;
+    hasPhysicalAddress: boolean;
+    campaigns: Array<{
+        platform: AdPlatform;
+        creative: CreativeContent;
+    }>;
+}): ComplianceReport;
+export type { ComplianceFinding, ComplianceReport, ComplianceSeverity, ComplianceCategory, CreativeContent };

package/dist/wizard/lib/compliance.js

@@ -0,0 +1,112 @@
+/**
+ * Szeth's Compliance Framework — Campaign compliance checks (§9.12).
+ *
+ * Every campaign is audited before launch. Critical compliance issues block launch.
+ * Covers: privacy (GDPR, cookie consent), email (CAN-SPAM), ad platform ToS,
+ * and financial reporting requirements.
+ *
+ * PRD Reference: §9.12 (Compliance Framework), §9.3 Phase 5
+ */
+// ── Privacy Checks (GDPR) ─────────────────────────────
+function checkPrivacy(hasTracking, targetsEU) {
+    const findings = [];
+    if (hasTracking && targetsEU) {
+        findings.push({
+            id: 'PRIV-001',
+            category: 'privacy',
+            severity: 'critical',
+            title: 'Cookie consent required',
+            description: 'Growth tracking (GA/Meta Pixel) targets EU users but no cookie consent banner detected.',
+            remediation: 'Generate a cookie consent banner with essential-only default, granular opt-in per tracking type.',
+            blocking: true,
+        });
+    }
+    return findings;
+}
+// ── Email Checks (CAN-SPAM) ──────────────────────────
+function checkEmail(hasOutreach, hasUnsubscribe, hasPhysicalAddress) {
+    const findings = [];
+    if (hasOutreach && !hasUnsubscribe) {
+        findings.push({
+            id: 'EMAIL-001',
+            category: 'email',
+            severity: 'critical',
+            title: 'Unsubscribe mechanism required',
+            description: 'Email outreach planned but no unsubscribe link in templates.',
+            remediation: 'Add unsubscribe link to every email template. Must be functional within 10 days.',
+            blocking: true,
+        });
+    }
+    if (hasOutreach && !hasPhysicalAddress) {
+        findings.push({
+            id: 'EMAIL-002',
+            category: 'email',
+            severity: 'high',
+            title: 'Physical address required',
+            description: 'CAN-SPAM requires a physical mailing address in every commercial email.',
+            remediation: 'Prompt user for business address during /grow Phase 5.',
+            blocking: false,
+        });
+    }
+    return findings;
+}
+function checkPlatformToS(platform, creative) {
+    const findings = [];
+    // Meta: no misleading claims, no before/after (health), no personal attributes
+    if (platform === 'meta') {
+        for (const headline of creative.headlines) {
+            if (/you (are|have|suffer|struggle)/i.test(headline)) {
+                findings.push({
+                    id: 'TOS-META-001',
+                    category: 'platform_tos',
+                    severity: 'high',
+                    title: 'Meta: personal attributes in ad copy',
+                    description: `Headline "${headline}" may violate Meta's personal attributes policy.`,
+                    remediation: 'Rewrite to avoid direct personal assertions. Use "People who..." instead of "You are..."',
+                    platform: 'meta',
+                    blocking: false,
+                });
+            }
+        }
+    }
+    // TikTok: age-gating for certain categories
+    if (platform === 'tiktok') {
+        // Check would require category classification — flag as a reminder
+        findings.push({
+            id: 'TOS-TIKTOK-001',
+            category: 'platform_tos',
+            severity: 'low',
+            title: 'TikTok: verify age restrictions',
+            description: 'TikTok requires age-gating for certain categories. Review targeting settings.',
+            remediation: 'Verify campaign targeting includes appropriate age restrictions for the product category.',
+            platform: 'tiktok',
+            blocking: false,
+        });
+    }
+    return findings;
+}
+// ── Main Compliance Audit ─────────────────────────────
+export function runComplianceAudit(projectId, options) {
+    const findings = [];
+    // Privacy checks
+    findings.push(...checkPrivacy(options.hasTracking, options.targetsEU));
+    // Email checks
+    findings.push(...checkEmail(options.hasOutreach, options.hasUnsubscribe, options.hasPhysicalAddress));
+    // Platform ToS checks per campaign
+    for (const campaign of options.campaigns) {
+        findings.push(...checkPlatformToS(campaign.platform, campaign.creative));
+    }
+    const summary = {
+        critical: findings.filter(f => f.severity === 'critical').length,
+        high: findings.filter(f => f.severity === 'high').length,
+        medium: findings.filter(f => f.severity === 'medium').length,
+        low: findings.filter(f => f.severity === 'low').length,
+    };
+    return {
+        projectId,
+        timestamp: new Date().toISOString(),
+        findings,
+        passed: summary.critical === 0,
+        summary,
+    };
+}

package/dist/wizard/lib/correlation-engine.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Chakotay's Correlation Engine — connects product changes to metric outcomes (v12.2).
+ *
+ * Maintains an event log of product changes (campaigns, deploys) and metric
+ * observations (traffic, conversions, revenue, performance scores). Computes
+ * before/after comparisons to identify which changes drove which outcomes.
+ *
+ * PRD Reference: ROADMAP v12.2, DEEP_CURRENT.md LEARN step
+ */
+import type { CampaignProposal } from './campaign-proposer.js';
+interface ChangeEvent {
+    type: 'campaign_complete' | 'deploy' | 'config_change';
+    date: string;
+    campaign?: string;
+    missions?: number;
+    dimension?: string;
+    description: string;
+}
+interface MetricObservation {
+    type: 'metric';
+    date: string;
+    metric: string;
+    value: number;
+    source: string;
+}
+interface Correlation {
+    type: 'correlation';
+    date: string;
+    productChange: string;
+    metric: string;
+    valueBefore: number;
+    valueAfter: number;
+    delta: string;
+    confidence: 'high' | 'medium' | 'low';
+    lagDays: number;
+}
+export declare function logCampaignComplete(name: string, missions: number, dimension: string): Promise<void>;
+export declare function logMetric(metric: string, value: number, source: string): Promise<void>;
+/**
+ * Detect correlations between recent campaigns and metric changes.
+ * Uses before/after comparison with configurable lag windows.
+ */
+export declare function detectCorrelations(lagDays?: number): Promise<Correlation[]>;
+interface PredictionRecord {
+    proposalId: string;
+    proposalName: string;
+    predictedImpact: string;
+    actualImpact?: string;
+    accuracy?: number;
+    recordedAt: string;
+    evaluatedAt?: string;
+}
+export declare function recordPrediction(proposal: CampaignProposal): Promise<void>;
+export declare function evaluatePrediction(proposalId: string, actualImpact: string, accuracy: number): Promise<void>;
+/**
+ * Calculate average prediction accuracy across all evaluated predictions.
+ */
+export declare function getAveragePredictionAccuracy(): Promise<number>;
+export type { ChangeEvent, MetricObservation, Correlation, PredictionRecord };

package/dist/wizard/lib/correlation-engine.js

@@ -0,0 +1,151 @@
+/**
+ * Chakotay's Correlation Engine — connects product changes to metric outcomes (v12.2).
+ *
+ * Maintains an event log of product changes (campaigns, deploys) and metric
+ * observations (traffic, conversions, revenue, performance scores). Computes
+ * before/after comparisons to identify which changes drove which outcomes.
+ *
+ * PRD Reference: ROADMAP v12.2, DEEP_CURRENT.md LEARN step
+ */
+import { appendFile, readFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { CORRELATIONS_PATH, PREDICTIONS_PATH, DEEP_CURRENT_DIR } from './deep-current.js';
+// ── Event Logging ─────────────────────────────────────
+async function appendEvent(entry) {
+    await mkdir(DEEP_CURRENT_DIR, { recursive: true });
+    await appendFile(CORRELATIONS_PATH, JSON.stringify(entry) + '\n', 'utf-8');
+}
+export async function logCampaignComplete(name, missions, dimension) {
+    await appendEvent({
+        type: 'campaign_complete',
+        date: new Date().toISOString(),
+        campaign: name,
+        missions,
+        dimension,
+        description: `Campaign "${name}" completed (${missions} missions, targeting ${dimension})`,
+    });
+}
+export async function logMetric(metric, value, source) {
+    await appendEvent({
+        type: 'metric',
+        date: new Date().toISOString(),
+        metric,
+        value,
+        source,
+    });
+}
+// ── Correlation Detection ─────────────────────────────
+/**
+ * Detect correlations between recent campaigns and metric changes.
+ * Uses before/after comparison with configurable lag windows.
+ */
+export async function detectCorrelations(lagDays = 7) {
+    if (!existsSync(CORRELATIONS_PATH))
+        return [];
+    const content = await readFile(CORRELATIONS_PATH, 'utf-8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    const events = lines.map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } }).filter(Boolean);
+    const changes = events.filter(e => e.type === 'campaign_complete');
+    const metrics = events.filter(e => e.type === 'metric');
+    const correlations = [];
+    for (const change of changes) {
+        const changeDate = new Date(change.date).getTime();
+        // Find metrics of the same type before and after the change
+        const metricNames = [...new Set(metrics.map(m => m.metric))];
+        for (const metricName of metricNames) {
+            const metricsOfType = metrics.filter(m => m.metric === metricName);
+            // Before: last metric reading before the change
+            const before = metricsOfType
+                .filter(m => new Date(m.date).getTime() < changeDate)
+                .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())[0];
+            // After: first metric reading lagDays after the change
+            const afterCutoff = changeDate + lagDays * 24 * 60 * 60 * 1000;
+            const after = metricsOfType
+                .filter(m => {
+                const t = new Date(m.date).getTime();
+                return t > changeDate && t <= afterCutoff;
+            })
+                .sort((a, b) => new Date(b.date).getTime() - new Date(a.date).getTime())[0];
+            if (before && after && before.value !== after.value) {
+                const delta = after.value - before.value;
+                const pctChange = before.value !== 0 ? Math.round((delta / before.value) * 100) : 0;
+                const significance = Math.abs(pctChange);
+                // Only record meaningful changes (>5%)
+                if (significance > 5) {
+                    const correlation = {
+                        type: 'correlation',
+                        date: new Date().toISOString(),
+                        productChange: change.campaign || change.description,
+                        metric: metricName,
+                        valueBefore: before.value,
+                        valueAfter: after.value,
+                        delta: `${delta > 0 ? '+' : ''}${pctChange}%`,
+                        confidence: significance > 30 ? 'high' : significance > 15 ? 'medium' : 'low',
+                        lagDays,
+                    };
+                    correlations.push(correlation);
+                    await appendEvent(correlation); // Record the correlation in the log
+                }
+            }
+        }
+    }
+    return correlations;
+}
+export async function recordPrediction(proposal) {
+    await mkdir(DEEP_CURRENT_DIR, { recursive: true });
+    const record = {
+        proposalId: proposal.id,
+        proposalName: proposal.name,
+        predictedImpact: proposal.expectedImpact,
+        recordedAt: new Date().toISOString(),
+    };
+    await appendFile(PREDICTIONS_PATH, JSON.stringify(record) + '\n', 'utf-8');
+}
+export async function evaluatePrediction(proposalId, actualImpact, accuracy) {
+    // Read existing predictions, find the matching one, update it
+    if (!existsSync(PREDICTIONS_PATH))
+        return;
+    const content = await readFile(PREDICTIONS_PATH, 'utf-8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    const updated = lines.map(line => {
+        try {
+            const record = JSON.parse(line);
+            if (record.proposalId === proposalId) {
+                record.actualImpact = actualImpact;
+                record.accuracy = accuracy;
+                record.evaluatedAt = new Date().toISOString();
+            }
+            return JSON.stringify(record);
+        }
+        catch {
+            return line;
+        }
+    });
+    const { writeFile: wf } = await import('node:fs/promises');
+    await wf(PREDICTIONS_PATH, updated.join('\n') + '\n');
+}
+/**
+ * Calculate average prediction accuracy across all evaluated predictions.
+ */
+export async function getAveragePredictionAccuracy() {
+    if (!existsSync(PREDICTIONS_PATH))
+        return 0;
+    const content = await readFile(PREDICTIONS_PATH, 'utf-8');
+    const records = content.trim().split('\n').filter(Boolean)
+        .map(l => { try {
+        return JSON.parse(l);
+    }
+    catch {
+        return null;
+    } })
+        .filter(Boolean);
+    const evaluated = records.filter(r => r.accuracy !== undefined);
+    if (evaluated.length === 0)
+        return 0;
+    return evaluated.reduce((sum, r) => sum + (r.accuracy || 0), 0) / evaluated.length;
+}

package/dist/wizard/lib/cost-estimator.d.ts

@@ -0,0 +1,22 @@
+/**
+ * AWS cost estimation before provisioning (ADR-022).
+ * Rough monthly cost estimate based on instance type, database, and cache.
+ * On-demand pricing — no reserved/spot. Informational only.
+ */
+import type { ProvisionEmitter } from './provisioners/types.js';
+export interface CostEstimate {
+    total: number;
+    breakdown: {
+        item: string;
+        monthly: number;
+    }[];
+}
+/**
+ * Estimate monthly AWS cost for a provisioning request.
+ * Returns null for non-AWS targets.
+ */
+export declare function estimateCost(deployTarget: string, instanceType: string, database: string, cache: string): CostEstimate | null;
+/**
+ * Emit a cost estimation SSE event before provisioning.
+ */
+export declare function emitCostEstimate(deployTarget: string, instanceType: string, database: string, cache: string, emit: ProvisionEmitter): void;

package/dist/wizard/lib/cost-estimator.js

@@ -0,0 +1,72 @@
+/**
+ * AWS cost estimation before provisioning (ADR-022).
+ * Rough monthly cost estimate based on instance type, database, and cache.
+ * On-demand pricing — no reserved/spot. Informational only.
+ */
+/** Monthly on-demand pricing (us-east-1, USD). Approximate as of 2025. */
+const EC2_MONTHLY = {
+    't3.micro': 8.50,
+    't3.small': 17.00,
+    't3.medium': 34.00,
+    't3.large': 67.00,
+};
+const RDS_MONTHLY = {
+    'db.t3.micro': 13.00,
+    'db.t3.small': 26.00,
+    'db.t3.medium': 52.00,
+    'db.t3.large': 104.00,
+};
+const CACHE_MONTHLY = {
+    'cache.t3.micro': 12.00,
+    'cache.t3.small': 24.00,
+    'cache.t3.medium': 48.00,
+    'cache.t3.large': 96.00,
+};
+/** S3 static hosting — rough estimate for a small site. */
+const S3_MONTHLY_BASE = 1.00;
+/**
+ * Estimate monthly AWS cost for a provisioning request.
+ * Returns null for non-AWS targets.
+ */
+export function estimateCost(deployTarget, instanceType, database, cache) {
+    if (deployTarget === 'vps') {
+        const breakdown = [];
+        const ec2Cost = EC2_MONTHLY[instanceType] || EC2_MONTHLY['t3.micro'];
+        breakdown.push({ item: `EC2 ${instanceType}`, monthly: ec2Cost });
+        if (database === 'postgres' || database === 'mysql') {
+            const rdsClass = `db.${instanceType}`;
+            const rdsCost = RDS_MONTHLY[rdsClass] || RDS_MONTHLY['db.t3.micro'];
+            breakdown.push({ item: `RDS ${rdsClass} (${database})`, monthly: rdsCost });
+        }
+        if (cache === 'redis') {
+            const cacheType = `cache.${instanceType}`;
+            const cacheCost = CACHE_MONTHLY[cacheType] || CACHE_MONTHLY['cache.t3.micro'];
+            breakdown.push({ item: `ElastiCache ${cacheType}`, monthly: cacheCost });
+        }
+        const total = breakdown.reduce((sum, b) => sum + b.monthly, 0);
+        return { total, breakdown };
+    }
+    if (deployTarget === 'static') {
+        return {
+            total: S3_MONTHLY_BASE,
+            breakdown: [{ item: 'S3 static hosting + data transfer', monthly: S3_MONTHLY_BASE }],
+        };
+    }
+    // Non-AWS targets — no cost estimate
+    return null;
+}
+/**
+ * Emit a cost estimation SSE event before provisioning.
+ */
+export function emitCostEstimate(deployTarget, instanceType, database, cache, emit) {
+    const estimate = estimateCost(deployTarget, instanceType, database, cache);
+    if (!estimate) {
+        if (['vercel', 'railway', 'cloudflare'].includes(deployTarget)) {
+            emit({ step: 'cost-estimate', status: 'done', message: `${deployTarget} pricing is usage-based — check their pricing page for details` });
+        }
+        return;
+    }
+    const lines = estimate.breakdown.map(b => `${b.item}: ~$${b.monthly.toFixed(2)}/mo`);
+    const message = `Estimated AWS cost: ~$${estimate.total.toFixed(2)}/month (${lines.join(', ')})`;
+    emit({ step: 'cost-estimate', status: 'done', message });
+}

package/dist/wizard/lib/cost-tracker.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Cost Tracker — Aggregate monthly costs across projects.
+ *
+ * Reads from the project registry's existing monthlyCost field.
+ * No separate store — data lives where it's already maintained.
+ */
+export interface ProjectCost {
+    projectId: string;
+    name: string;
+    monthlyCost: number;
+    deployTarget: string;
+}
+export interface AggregateCosts {
+    totalMonthlyCost: number;
+    projects: ProjectCost[];
+    alertThreshold: number;
+    isOverThreshold: boolean;
+}
+/**
+ * Get aggregate costs for all projects visible to a user.
+ * Admins see all projects; others see owned + shared.
+ */
+export declare function getAggregateCosts(username: string, globalRole: string, alertThreshold?: number): Promise<AggregateCosts>;
+/**
+ * Update monthly cost for a project (called after deploy or manual update).
+ */
+export declare function setProjectCost(projectId: string, monthlyCost: number): Promise<void>;

package/dist/wizard/lib/cost-tracker.js

@@ -0,0 +1,37 @@
+/**
+ * Cost Tracker — Aggregate monthly costs across projects.
+ *
+ * Reads from the project registry's existing monthlyCost field.
+ * No separate store — data lives where it's already maintained.
+ */
+import { getProjectsForUser, updateProject } from './project-registry.js';
+const DEFAULT_ALERT_THRESHOLD = 100; // $100/mo
+/**
+ * Get aggregate costs for all projects visible to a user.
+ * Admins see all projects; others see owned + shared.
+ */
+export async function getAggregateCosts(username, globalRole, alertThreshold = DEFAULT_ALERT_THRESHOLD) {
+    const projects = await getProjectsForUser(username, globalRole);
+    const costs = projects.map((p) => ({
+        projectId: p.id,
+        name: p.name,
+        monthlyCost: p.monthlyCost || 0,
+        deployTarget: p.deployTarget,
+    }));
+    const totalMonthlyCost = costs.reduce((sum, c) => sum + c.monthlyCost, 0);
+    return {
+        totalMonthlyCost,
+        projects: costs,
+        alertThreshold,
+        isOverThreshold: totalMonthlyCost > alertThreshold,
+    };
+}
+/**
+ * Update monthly cost for a project (called after deploy or manual update).
+ */
+export async function setProjectCost(projectId, monthlyCost) {
+    if (!Number.isFinite(monthlyCost) || monthlyCost < 0) {
+        throw new Error('monthlyCost must be a non-negative finite number');
+    }
+    await updateProject(projectId, { monthlyCost });
+}