@mindflight/mindbrain-personal-studio 0.6.1 → 0.6.2

package/scripts/materialize-serenity-v6-snapshots.mjs

@@ -1,675 +0,0 @@
-#!/usr/bin/env node
-import { copyFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { spawnSync } from 'node:child_process';
-
-const WORKSPACE = 'serenity-production-v6';
-const DEFAULT_DB = '/home/dlamotte/.ghostcrab/databases/ghostcrab-serenity-v4-demos.sqlite';
-const DEFAULT_BACKUP_DIR = '/tmp/serenity-v6-snapshot-backups';
-const GENERATOR = 'serenity-v6-snapshot-generator';
-const args = new Set(process.argv.slice(2));
-const apply = args.has('--apply');
-const verbose = args.has('--verbose');
-const emitSqlPath = valueAfter('--emit-sql');
-const dbPath = valueAfter('--db') ?? process.env.GHOSTCRAB_SQLITE_PATH ?? DEFAULT_DB;
-const backupDir = valueAfter('--backup-dir') ?? DEFAULT_BACKUP_DIR;
-const now = Math.floor(Date.now() / 1000);
-
-const NEW_SCENARIOS = [
-	{
-		scenario_id: 'scn.v6.mandataire_appel_fonds_contact',
-		projection_id: 'scenario_v6_mandataire_appel_fonds_contact',
-		public_label: 'Mandataire contacte avec les proprietaires lors d un appel de fonds',
-		business_question:
-			"Qui doit recevoir l'appel de fonds quand un mandataire represente plusieurs lots et comment prouver que le calcul reste rattache aux bons proprietaires ?",
-		copropriete: 'copropriete.tilleuls',
-		workflow: 'fund_call_delegated_contact',
-		records: [
-			['mandataire', 'Mandataire Dupont famille Tilleuls'],
-			['personne', 'Claire Dupont mandataire'],
-			['lot', 'Lot A3 represente par mandataire'],
-			['fund_call', 'Appel FDRO delegue Tilleuls T2'],
-			['fund_call_line', 'Ligne appel fonds lot A3 mandataire'],
-			['preuve_documentaire', 'Courrier de mandat et preuve d envoi']
-		],
-		statuses: [
-			'mandat: received -> verified -> active',
-			'fund_call: draft -> computed -> emitted',
-			'notification: prepared -> sent_to_owner_and_mandataire -> acknowledged'
-		],
-		requirements: [
-			'fund_call.contacts_mandataire',
-			'mandataire.represents_lot',
-			'fund_call_line.account_for_lot'
-		]
-	},
-	{
-		scenario_id: 'scn.v6.offre_prix_revision_bon_commande',
-		projection_id: 'scenario_v6_offre_prix_revision_bon_commande',
-		public_label: 'Offre de prix revisee puis acceptee comme bon de commande',
-		business_question:
-			"Quelle version du devis a ete acceptee, quel montant engage-t-elle et quel bon de commande en decoule ?",
-		copropriete: 'copropriete.horizon',
-		workflow: 'quote_revision_to_purchase_order',
-		records: [
-			['demande_travaux', 'Demande remplacement parlophone Galerie Horizon'],
-			['offre_prix', 'Offre prix initiale Parlophone SA'],
-			['offre_prix', 'Offre prix revisee Parlophone SA'],
-			['bon_commande', 'Bon commande parlophone Horizon'],
-			['supplier_intervention', 'Intervention planifiee parlophone Horizon'],
-			['preuve_documentaire', 'PV acceptation devis revise']
-		],
-		statuses: [
-			'quote: requested -> received -> revised -> accepted',
-			'purchase_order: draft -> signed -> sent_to_supplier',
-			'intervention: planned -> waiting_supplier'
-		],
-		requirements: [
-			'demande_travaux.requests_quote',
-			'offre_prix.revised_as',
-			'offre_prix.accepted_as_purchase_order'
-		]
-	},
-	{
-		scenario_id: 'scn.v6.extrait_bancaire_rapprochement',
-		projection_id: 'scenario_v6_extrait_bancaire_rapprochement',
-		public_label: 'Extrait bancaire rapproche avec ecriture comptable et facture',
-		business_question:
-			"Quel mouvement bancaire justifie le paiement, quelle facture est soldee et quelle ecriture comptable ferme le rapprochement ?",
-		copropriete: 'copropriete.erables',
-		workflow: 'bank_statement_reconciliation',
-		records: [
-			['extrait_compte_bancaire', 'Extrait bancaire Erables mars 2026'],
-			['bank_movement', 'Mouvement paiement chaufferie mars 2026'],
-			['supplier_invoice', 'Facture chaufferie Erables mars 2026'],
-			['accounting_entry', 'Ecriture paiement facture chaufferie'],
-			['payment_reconciliation', 'Rapprochement facture paiement chaufferie'],
-			['preuve_documentaire', 'PDF extrait bancaire et facture fournisseur']
-		],
-		statuses: [
-			'bank_statement: imported -> parsed -> reconciled',
-			'invoice: received -> booked -> paid',
-			'reconciliation: candidate -> matched -> verified'
-		],
-		requirements: [
-			'extrait_compte_bancaire.documents_account',
-			'bank_movement.pays_invoice',
-			'accounting_entry.supports_reconciliation'
-		]
-	}
-];
-
-function valueAfter(flag) {
-	const index = process.argv.indexOf(flag);
-	return index >= 0 ? process.argv[index + 1] : null;
-}
-
-function runSql(sql, { json = false, readonly = false } = {}) {
-	const argv = [];
-	if (readonly) argv.push('-readonly');
-	if (json) argv.push('-json');
-	argv.push(dbPath, sql);
-	const result = spawnSync('sqlite3', argv, { encoding: 'utf8', maxBuffer: 1024 * 1024 * 128 });
-	if (result.status !== 0) throw new Error(result.stderr || result.stdout || `sqlite3 failed: ${sql.slice(0, 180)}`);
-	return json ? JSON.parse(result.stdout || '[]') : result.stdout.trim();
-}
-
-function runSqlFile(sql) {
-	if (verbose) console.error(`[${GENERATOR}] applying sql bytes=${Buffer.byteLength(sql, 'utf8')}`);
-	mkdirSync(backupDir, { recursive: true });
-	const sqlPath = join(backupDir, `${WORKSPACE}-${process.pid}-${Date.now()}.sql`);
-	writeFileSync(sqlPath, sql);
-	const result = spawnSync('sqlite3', [dbPath, `.read ${sqlPath}`], {
-		encoding: 'utf8',
-		maxBuffer: 1024 * 1024 * 128
-	});
-	if (result.status !== 0) throw new Error(result.stderr || result.stdout || 'sqlite3 transaction failed');
-	return result.stdout;
-}
-
-function q(value) {
-	if (value === null || value === undefined) return 'NULL';
-	if (typeof value === 'number') return Number.isFinite(value) ? String(value) : 'NULL';
-	if (typeof value === 'boolean') return value ? '1' : '0';
-	return `'${String(value).replaceAll("'", "''")}'`;
-}
-
-function slug(value) {
-	return String(value)
-		.toLowerCase()
-		.normalize('NFD')
-		.replace(/[\u0300-\u036f]/g, '')
-		.replace(/[^a-z0-9]+/g, '_')
-		.replace(/^_+|_+$/g, '');
-}
-
-function parseJson(value, fallback = {}) {
-	try {
-		return JSON.parse(value || '');
-	} catch {
-		return fallback;
-	}
-}
-
-function jsonSql(value) {
-	return q(JSON.stringify(value));
-}
-
-function readScenarioPlans() {
-	return runSql(
-		`
-		SELECT artifact_id, slug, public_label, scope, payload_json
-		FROM mindbrain_answer_artifacts
-		WHERE workspace_id=${q(WORKSPACE)}
-		  AND artifact_kind='analysis_plan'
-		  AND scope LIKE ${q(`${WORKSPACE}:scenario:%`)}
-		ORDER BY artifact_id;
-		`,
-		{ json: true, readonly: true }
-	).map((row) => {
-		const payload = parseJson(row.payload_json);
-		const refs = Array.isArray(payload.scenario_refs) ? payload.scenario_refs : [];
-		const scenarioId = refs[0] ?? payload.projection_id ?? row.slug;
-		return {
-			source: 'existing',
-			artifact_id: row.artifact_id,
-			slug: row.slug,
-			public_label: row.public_label,
-			scope: row.scope,
-			projection_id: payload.projection_id ?? slug(row.public_label),
-			business_question: payload.business_question ?? payload.summary ?? row.public_label,
-			scenario_id: scenarioId,
-			required_edges: Array.isArray(payload.required_edges) ? payload.required_edges : [],
-			required_facets: Array.isArray(payload.required_facets) ? payload.required_facets : [],
-			scenario_refs: refs
-		};
-	});
-}
-
-function readScenarioEntityMap() {
-	const rows = runSql(
-		`
-		SELECT entity_id, entity_type, name, metadata_json
-		FROM graph_entity
-		WHERE workspace_id=${q(WORKSPACE)}
-		  AND (
-		    entity_type='scenario_gestion'
-		    OR json_extract(metadata_json, '$.scenario_id') IS NOT NULL
-		  )
-		ORDER BY entity_id;
-		`,
-		{ json: true, readonly: true }
-	);
-	const byScenario = new Map();
-	for (const row of rows) {
-		const metadata = parseJson(row.metadata_json);
-		const scenarioId = metadata.scenario_id ?? (row.entity_type === 'scenario_gestion' ? row.name : null);
-		if (!scenarioId) continue;
-		if (!byScenario.has(scenarioId)) byScenario.set(scenarioId, []);
-		byScenario.get(scenarioId).push({
-			entity_id: Number(row.entity_id),
-			entity_type: row.entity_type,
-			name: row.name,
-			metadata
-		});
-	}
-	return byScenario;
-}
-
-function readScenarioRelationCounts() {
-	const rows = runSql(
-		`
-		SELECT s.name AS scenario_id, COUNT(r.relation_id) AS relation_count,
-		       group_concat(DISTINCT r.relation_type) AS relation_types
-		FROM graph_entity s
-		LEFT JOIN graph_relation r ON r.workspace_id=s.workspace_id AND r.source_id=s.entity_id
-		WHERE s.workspace_id=${q(WORKSPACE)}
-		  AND s.entity_type='scenario_gestion'
-		GROUP BY s.entity_id, s.name;
-		`,
-		{ json: true, readonly: true }
-	);
-	return new Map(
-		rows.map((row) => [
-			row.scenario_id,
-			{
-				relation_count: Number(row.relation_count ?? 0),
-				relation_types: row.relation_types ? String(row.relation_types).split(',') : []
-			}
-		])
-	);
-}
-
-function newScenarioPlan(def) {
-	return {
-		source: 'generated',
-		artifact_id: `analysis_plan__${WORKSPACE.replaceAll('-', '_')}_scenario_${def.projection_id}`,
-		slug: `${WORKSPACE.replaceAll('-', '_')}_scenario_${def.projection_id}`,
-		public_label: def.public_label,
-		scope: `${WORKSPACE}:scenario:${def.projection_id}`,
-		projection_id: def.projection_id,
-		business_question: def.business_question,
-		scenario_id: def.scenario_id,
-		required_edges: ['scenario_requires_record', 'scenario_requires_relation', 'scenario_has_status_event', 'scenario_for_copropriete'],
-		required_facets: ['status', 'scenario_status', 'copropriete_id', 'actor_refs', 'evidence_refs'],
-		scenario_refs: [def.scenario_id],
-		def
-	};
-}
-
-function syntheticRuntimeRows(def) {
-	const rows = [{ entity_type: 'scenario_gestion', name: def.scenario_id, role: 'scenario' }];
-	for (let index = 0; index < def.records.length; index += 1) {
-		const [entityType, label] = def.records[index];
-		rows.push({
-			entity_type: entityType,
-			name: `${def.scenario_id}.${slug(entityType)}.${String(index + 1).padStart(2, '0')}`,
-			label,
-			role: 'runtime_record'
-		});
-	}
-	for (let index = 0; index < def.statuses.length; index += 1) {
-		rows.push({
-			entity_type: 'status_event',
-			name: `${def.scenario_id}.status_event.${String(index + 1).padStart(2, '0')}`,
-			label: def.statuses[index],
-			role: 'status_event',
-			transition: def.statuses[index]
-		});
-	}
-	for (let index = 0; index < def.requirements.length; index += 1) {
-		rows.push({
-			entity_type: 'relation_requirement',
-			name: `${def.scenario_id}.relation_requirement.${String(index + 1).padStart(2, '0')}`,
-			label: def.requirements[index],
-			role: 'relation_requirement',
-			relation_requirement: def.requirements[index]
-		});
-	}
-	return rows;
-}
-
-function syntheticEntityNameSql(name) {
-	return `(SELECT entity_id FROM graph_entity WHERE workspace_id=${q(WORKSPACE)} AND name=${q(name)} LIMIT 1)`;
-}
-
-function buildNewScenarioSql(plan) {
-	const def = plan.def;
-	const statements = [];
-	const basePayload = {
-		projection_id: plan.projection_id,
-		source: `${GENERATOR}.analysis_plan`,
-		origin: 'synthetic_scenario',
-		decision_level: 'operational_scenario',
-		artifact_kind: 'analysis_plan',
-		proj_type: 'STEP',
-		scope: plan.scope,
-		label: plan.public_label,
-		business_question: plan.business_question,
-		description: def.public_label,
-		required_schemas: [],
-		required_facets: plan.required_facets,
-		required_edges: plan.required_edges,
-		retrieval_jobs: ['scenario_state', 'scenario_evidence'],
-		status_filter_policy: 'current_by_default',
-		scenario_refs: plan.scenario_refs,
-		synthetic: true,
-		generated_by: GENERATOR
-	};
-	statements.push(`
-		INSERT INTO mindbrain_answer_artifacts (
-			artifact_id, slug, workspace_id, agent_id, scope, artifact_kind,
-			public_label_key, public_label, lifecycle, state, current_version,
-			payload_json, legacy_ref, created_at_unix, updated_at_unix
-		)
-		VALUES (
-			${q(plan.artifact_id)}, ${q(plan.slug)}, ${q(WORKSPACE)}, ${q(`agent:${WORKSPACE}:snapshot-generator`)},
-			${q(plan.scope)}, 'analysis_plan', ${q(`analysis_plan.${WORKSPACE}.${plan.projection_id}`)},
-			${q(plan.public_label)}, 'active', 'open', 1, ${jsonSql(basePayload)}, NULL, ${now}, ${now}
-		)
-		ON CONFLICT(artifact_id) DO UPDATE SET
-			public_label=excluded.public_label,
-			scope=excluded.scope,
-			payload_json=excluded.payload_json,
-			updated_at_unix=excluded.updated_at_unix;
-	`);
-	statements.push(`
-		INSERT INTO mindbrain_answer_artifacts (
-			artifact_id, slug, workspace_id, agent_id, scope, artifact_kind,
-			public_label_key, public_label, lifecycle, state, current_version,
-			payload_json, legacy_ref, created_at_unix, updated_at_unix
-		)
-		VALUES (
-			${q(`live_answer_view__${plan.slug}`)}, ${q(plan.slug)}, ${q(WORKSPACE)}, NULL, NULL,
-			'live_answer_view', ${q(`live_answer_view.${WORKSPACE}.${plan.projection_id}`)},
-			${q(plan.public_label)}, 'active', 'refreshed', 1,
-			${jsonSql({
-				source_plan_id: plan.artifact_id,
-				source_plan_scope: plan.scope,
-				projection_id: plan.projection_id,
-				summary: plan.business_question,
-				refresh_checks: ['graph relation coverage', 'status filter coverage', 'required evidence coverage'],
-				required_edges: plan.required_edges,
-				required_facets: plan.required_facets,
-				scenario_refs: plan.scenario_refs,
-				synthetic: true,
-				generated_by: GENERATOR
-			})},
-			NULL, ${now}, ${now}
-		)
-		ON CONFLICT(artifact_id) DO UPDATE SET
-			payload_json=excluded.payload_json,
-			state=excluded.state,
-			updated_at_unix=excluded.updated_at_unix;
-	`);
-	for (const row of syntheticRuntimeRows(def)) {
-		const metadata = {
-			display_name: row.label ?? def.public_label,
-			source_id: row.name,
-			source: GENERATOR,
-			scenario_id: def.scenario_id,
-			runtime_record_type: row.role,
-			transition: row.transition,
-			relation_requirement: row.relation_requirement,
-			synthetic: true
-		};
-		statements.push(`
-			INSERT INTO graph_entity (workspace_id, entity_type, name, confidence, metadata_json)
-			VALUES (${q(WORKSPACE)}, ${q(row.entity_type)}, ${q(row.name)}, 0.96, ${jsonSql(metadata)})
-			ON CONFLICT(workspace_id, entity_type, name)
-			DO UPDATE SET confidence=excluded.confidence, metadata_json=excluded.metadata_json, deprecated_at=NULL;
-		`);
-	}
-	for (const row of syntheticRuntimeRows(def).filter((item) => item.name !== def.scenario_id)) {
-		const relationType =
-			row.role === 'status_event'
-				? 'scenario_has_status_event'
-				: row.role === 'relation_requirement'
-					? 'scenario_requires_relation'
-					: 'scenario_requires_record';
-		statements.push(relationSql(relationType, def.scenario_id, row.name, {
-			source: GENERATOR,
-			scenario_id: def.scenario_id,
-			synthetic: true
-		}));
-	}
-	return statements;
-}
-
-function relationSql(type, sourceName, targetName, metadata) {
-	return `
-		INSERT INTO graph_relation (workspace_id, relation_type, source_id, target_id, confidence, metadata_json)
-		SELECT ${q(WORKSPACE)}, ${q(type)}, s.entity_id, t.entity_id, 0.98, ${jsonSql({
-			...metadata,
-			relation_group: 'synthetic_scenario'
-		})}
-		FROM graph_entity s, graph_entity t
-		WHERE s.workspace_id=${q(WORKSPACE)} AND s.name=${q(sourceName)}
-		  AND t.workspace_id=${q(WORKSPACE)} AND t.name=${q(targetName)};
-	`;
-}
-
-function topEntitiesForPlan(plan, entityMap) {
-	const rows = entityMap.get(plan.scenario_id) ?? [];
-	const scenario = rows.find((row) => row.entity_type === 'scenario_gestion');
-	const runtime = rows.filter((row) => row.entity_type !== 'scenario_gestion');
-	const evidence = runtime.filter((row) =>
-		['preuve_documentaire', 'proof_document', 'death_certificate_evidence', 'claim_statement'].includes(row.entity_type)
-	);
-	const statusEvents = runtime.filter((row) => row.entity_type === 'status_event');
-	const requirements = runtime.filter((row) => row.entity_type === 'relation_requirement');
-	return {
-		scenario,
-		runtime,
-		evidence,
-		statusEvents,
-		requirements,
-		seedIds: [scenario, ...runtime.slice(0, 5)].filter(Boolean).map((row) => row.entity_id)
-	};
-}
-
-function snapshotPayload(plan, kind, entityMap, relationCounts) {
-	const entities = topEntitiesForPlan(plan, entityMap);
-	const relationInfo = relationCounts.get(plan.scenario_id) ?? { relation_count: 0, relation_types: [] };
-	const runtimeIds = entities.runtime.map((row) => row.entity_id).filter(Number.isFinite);
-	const evidenceIds = entities.evidence.map((row) => row.entity_id).filter(Number.isFinite);
-	const deltaIds = entities.requirements.slice(0, 4).map((row) => row.entity_id).filter(Number.isFinite);
-	const timeline = entities.statusEvents.map((row) => ({
-		entity_id: row.entity_id,
-		name: row.name,
-		transition: row.metadata.transition ?? row.metadata.display_name ?? row.name
-	}));
-	const base = {
-		source_plan_id: plan.artifact_id,
-		source_plan_scope: plan.scope,
-		projection_id: plan.projection_id,
-		scenario_id: plan.scenario_id,
-		scenario_refs: plan.scenario_refs,
-		business_question: plan.business_question,
-		snapshot_kind: kind,
-		summary:
-			kind === 'scenario_state'
-				? `${plan.public_label}: ${runtimeIds.length} objets runtime, ${timeline.length} transitions et ${relationInfo.relation_count} relations scenario.`
-				: `${plan.public_label}: ${evidenceIds.length} preuves directes, ${deltaIds.length} exigences/deltas et ${relationInfo.relation_types.length} types de relations.`,
-		runtime_entity_ids: runtimeIds,
-		evidence_entity_ids: evidenceIds,
-		delta_entity_ids: deltaIds,
-		seed_ids: entities.seedIds,
-		status_timeline: timeline,
-		relation_coverage: {
-			relation_count: relationInfo.relation_count,
-			relation_types: relationInfo.relation_types
-		},
-		required_edges: plan.required_edges,
-		required_facets: plan.required_facets,
-		synthetic: plan.source === 'generated',
-		generated_by: GENERATOR,
-		generated_at_unix: now
-	};
-	if (kind === 'scenario_evidence') {
-		base.deltas = entities.requirements.slice(0, 6).map((row) => ({
-			entity_id: row.entity_id,
-			requirement: row.metadata.relation_requirement ?? row.metadata.display_name ?? row.name,
-			status: evidenceIds.length > 0 ? 'covered' : 'needs_evidence'
-		}));
-	}
-	return base;
-}
-
-function buildSnapshotSql(plan, kind, entityMap, relationCounts) {
-	const payload = snapshotPayload(plan, kind, entityMap, relationCounts);
-	const snapshotSlug = `${plan.slug}__${kind}`;
-	const artifactId = `answer_snapshot__${snapshotSlug}`;
-	const title = `${plan.public_label} - ${kind === 'scenario_state' ? 'etat scenario' : 'preuves et deltas'}`;
-	const projectionName = `projection_result.${plan.projection_id}.${kind}`;
-	const metadata = {
-		artifact_id: artifactId,
-		artifact_kind: 'answer_snapshot',
-		public_label: title,
-		projection_id: plan.projection_id,
-		source_plan_id: plan.artifact_id,
-		scenario_id: plan.scenario_id,
-		snapshot_kind: kind,
-		seed_ids: payload.seed_ids,
-		source: GENERATOR,
-		workspace_id: WORKSPACE,
-		synthetic: payload.synthetic,
-		relation_group: 'snapshot'
-	};
-	const relationStatements = [];
-	const scenarioEntity = (entityMap.get(plan.scenario_id) ?? []).find((row) => row.entity_type === 'scenario_gestion');
-	if (scenarioEntity) {
-		relationStatements.push(`
-			INSERT INTO graph_relation (workspace_id, relation_type, source_id, target_id, confidence, metadata_json)
-			SELECT ${q(WORKSPACE)}, 'SNAPSHOT_FOR_SCENARIO', p.entity_id, ${scenarioEntity.entity_id}, 1.0, ${jsonSql(metadata)}
-			FROM graph_entity p
-			WHERE p.workspace_id=${q(WORKSPACE)} AND p.entity_type='ProjectionResult' AND p.name=${q(projectionName)};
-		`);
-	}
-	for (const targetId of payload.seed_ids.slice(0, 8)) {
-		relationStatements.push(`
-			INSERT INTO graph_relation (workspace_id, relation_type, source_id, target_id, confidence, metadata_json)
-			SELECT ${q(WORKSPACE)}, 'SNAPSHOT_REFERENCES_OBJECT', p.entity_id, ${targetId}, 0.97, ${jsonSql(metadata)}
-			FROM graph_entity p
-			WHERE p.workspace_id=${q(WORKSPACE)} AND p.entity_type='ProjectionResult' AND p.name=${q(projectionName)};
-		`);
-	}
-	for (const targetId of payload.delta_entity_ids.slice(0, 4)) {
-		relationStatements.push(`
-			INSERT INTO graph_relation (workspace_id, relation_type, source_id, target_id, confidence, metadata_json)
-			SELECT ${q(WORKSPACE)}, 'SNAPSHOT_HAS_DELTA', p.entity_id, ${targetId}, 0.94, ${jsonSql(metadata)}
-			FROM graph_entity p
-			WHERE p.workspace_id=${q(WORKSPACE)} AND p.entity_type='ProjectionResult' AND p.name=${q(projectionName)};
-		`);
-	}
-	return [
-		`
-		INSERT INTO mindbrain_answer_artifacts (
-			artifact_id, slug, workspace_id, agent_id, scope, artifact_kind,
-			public_label_key, public_label, lifecycle, state, current_version,
-			payload_json, legacy_ref, created_at_unix, updated_at_unix
-		)
-		VALUES (
-			${q(artifactId)}, ${q(snapshotSlug)}, ${q(WORKSPACE)}, NULL, ${q(plan.scope)},
-			'answer_snapshot', ${q(`answer_snapshot.${WORKSPACE}.${plan.projection_id}.${kind}`)},
-			${q(title)}, 'frozen', 'ready', 1, ${jsonSql(payload)}, NULL, ${now}, ${now}
-		)
-		ON CONFLICT(artifact_id) DO UPDATE SET
-			public_label=excluded.public_label,
-			scope=excluded.scope,
-			lifecycle=excluded.lifecycle,
-			state=excluded.state,
-			current_version=excluded.current_version,
-			payload_json=excluded.payload_json,
-			updated_at_unix=excluded.updated_at_unix;
-		`,
-		`
-		INSERT INTO graph_entity (workspace_id, entity_type, name, confidence, metadata_json)
-		VALUES (${q(WORKSPACE)}, 'ProjectionResult', ${q(projectionName)}, 1.0, ${jsonSql(metadata)})
-		ON CONFLICT(workspace_id, entity_type, name)
-		DO UPDATE SET confidence=excluded.confidence, metadata_json=excluded.metadata_json, deprecated_at=NULL;
-		`,
-		...relationStatements
-	];
-}
-
-function buildNewScenarioDataSql(generatedPlans) {
-	const statements = [];
-	statements.push(
-		`DELETE FROM graph_relation WHERE workspace_id=${q(WORKSPACE)} AND json_extract(metadata_json, '$.source')=${q(GENERATOR)} AND json_extract(metadata_json, '$.relation_group')='synthetic_scenario';`
-	);
-	for (const plan of generatedPlans) statements.push(...buildNewScenarioSql(plan));
-	return ['PRAGMA foreign_keys=ON;', 'BEGIN IMMEDIATE;', ...statements, 'COMMIT;'].join('\n');
-}
-
-function buildSnapshotDataSql(plans) {
-	const entityMap = readScenarioEntityMap();
-	const relationCounts = readScenarioRelationCounts();
-	const statements = [
-		`DELETE FROM graph_relation WHERE workspace_id=${q(WORKSPACE)} AND json_extract(metadata_json, '$.source')=${q(GENERATOR)} AND json_extract(metadata_json, '$.relation_group')='snapshot';`
-	];
-	for (const plan of plans) {
-		for (const kind of ['scenario_state', 'scenario_evidence']) {
-			statements.push(...buildSnapshotSql(plan, kind, entityMap, relationCounts));
-		}
-	}
-	return ['PRAGMA foreign_keys=ON;', 'BEGIN IMMEDIATE;', ...statements, 'COMMIT;'].join('\n');
-}
-
-function backupDb() {
-	mkdirSync(backupDir, { recursive: true });
-	const backupPath = join(backupDir, `${WORKSPACE}-pre-snapshots-${new Date().toISOString().replaceAll(':', '-')}.sqlite`);
-	copyFileSync(dbPath, backupPath);
-	return backupPath;
-}
-
-function counts() {
-	const rows = runSql(
-		`
-		SELECT 'answer_snapshot_artifacts' AS name, COUNT(*) AS count
-		FROM mindbrain_answer_artifacts
-		WHERE workspace_id=${q(WORKSPACE)} AND artifact_kind='answer_snapshot'
-		UNION ALL
-		SELECT 'projection_results' AS name, COUNT(*) AS count
-		FROM graph_entity
-		WHERE workspace_id=${q(WORKSPACE)} AND entity_type='ProjectionResult'
-		UNION ALL
-		SELECT 'scenario_plans' AS name, COUNT(*) AS count
-		FROM mindbrain_answer_artifacts
-		WHERE workspace_id=${q(WORKSPACE)} AND artifact_kind='analysis_plan' AND scope LIKE ${q(`${WORKSPACE}:scenario:%`)};
-		`,
-		{ json: true, readonly: true }
-	);
-	return Object.fromEntries(rows.map((row) => [row.name, Number(row.count)]));
-}
-
-function main() {
-	if (verbose) console.error(`[${GENERATOR}] reading counts`);
-	const before = counts();
-	if (verbose) console.error(`[${GENERATOR}] reading existing scenario plans`);
-	const existingPlans = readScenarioPlans();
-	const generatedPlans = NEW_SCENARIOS.map(newScenarioPlan);
-	const existingPlanIds = new Set(existingPlans.map((plan) => plan.artifact_id));
-	const missingGeneratedPlans = generatedPlans.filter((plan) => !existingPlanIds.has(plan.artifact_id));
-	const expectedPlanCount = existingPlans.length + missingGeneratedPlans.length;
-	const plannedSnapshots = expectedPlanCount * 2;
-	if (emitSqlPath) {
-		const previewSql = [
-			'-- new scenario data',
-			buildNewScenarioDataSql(generatedPlans),
-			'-- snapshot data for current plans only',
-			buildSnapshotDataSql(existingPlans)
-		].join('\n');
-		writeFileSync(emitSqlPath, previewSql);
-		console.log(JSON.stringify({ mode: 'emit-sql', path: emitSqlPath, bytes: Buffer.byteLength(previewSql, 'utf8') }, null, 2));
-		return;
-	}
-	if (!apply) {
-		console.log(
-			JSON.stringify(
-				{
-					mode: 'dry-run',
-					db_path: dbPath,
-					workspace_id: WORKSPACE,
-					existing_scenarios: existingPlans.length,
-					new_scenarios: missingGeneratedPlans.length,
-					planned_snapshots: plannedSnapshots,
-					planned_projection_results: plannedSnapshots,
-					before
-				},
-				null,
-				2
-			)
-		);
-		return;
-	}
-	if (verbose) console.error(`[${GENERATOR}] backing up`);
-	const backupPath = backupDb();
-	if (verbose) console.error(`[${GENERATOR}] applying generated scenario data`);
-	runSqlFile(buildNewScenarioDataSql(generatedPlans));
-	if (verbose) console.error(`[${GENERATOR}] reading plans after generated data`);
-	const plansAfterScenarioData = readScenarioPlans();
-	if (verbose) console.error(`[${GENERATOR}] applying snapshot data for ${plansAfterScenarioData.length} plans`);
-	runSqlFile(buildSnapshotDataSql(plansAfterScenarioData));
-	if (verbose) console.error(`[${GENERATOR}] reading final counts`);
-	const after = counts();
-	console.log(
-		JSON.stringify(
-			{
-				mode: 'apply',
-				db_path: dbPath,
-				workspace_id: WORKSPACE,
-				backup_path: backupPath,
-				existing_scenarios: existingPlans.length,
-				new_scenarios: missingGeneratedPlans.length,
-				planned_snapshots: plannedSnapshots,
-				before,
-				after
-			},
-			null,
-			2
-		)
-	);
-}
-
-main();