@obsunified/collector 2.0.1 → 2.2.0

package/src/lib/action-retention.ts

@@ -0,0 +1,420 @@
+/**
+ * Retention for the RFC 0010 action graph (`actions` spine plus the
+ * `agent_runs`, `tool_calls`, `retrieval_events`, `eval_results` and
+ * `artifacts` leaves).
+ *
+ * Unlike the telemetry tables these rows carry no `expires_at`; the sweep
+ * derives expiry from `actions.started_at` and the configured
+ * `RETENTION_HOURS`. The unit of deletion is the causal tree
+ * (`project_id`, `root_action_id`): a tree is selected, rechecked and
+ * removed as a whole inside one `SqlDb.batch` (a D1 batch or a Postgres
+ * transaction), never action by action. A tree is kept whole while any of
+ * its actions:
+ *
+ *   - started inside the retention window,
+ *   - is still in progress (`ended_at IS NULL`),
+ *   - belongs to an `agent_runs` row whose `status` is `running`,
+ *   - is referenced by an `eval_cases` row in the same project via
+ *     `source_action_id`, `source_agent_run_id`, or (through a `tool_calls`
+ *     row) `source_tool_call_id`.
+ *
+ * Work is bounded per invocation: each batch packs whole trees up to
+ * `maxActionsPerBatch` actions and `maxTreesPerBatch` trees, and the sweep
+ * stops after `maxBatches`. A tree with more than `maxActionsPerBatch`
+ * actions can never be deleted atomically within those bounds, so it is
+ * retained intact and reported as `oversized_trees` (and logged by the
+ * handler) instead of being deleted in pieces. Raise `maxActionsPerBatch`
+ * to reclaim such trees.
+ *
+ * Concurrency: every DELETE repeats the eligibility predicate, so a tree
+ * that gained a fresh or unfinished action, a `running` run, or an eval
+ * case between selection and deletion is left alone. On D1 the batch is a
+ * single serialized SQLite transaction, so that recheck is airtight. On
+ * Postgres (READ COMMITTED) each statement sees writes committed before it
+ * started, so a commit landing between the leaf deletes and the final spine
+ * delete of the same tree could leave that tree's spine without its leaves.
+ * That needs an ingest for a tree whose newest action is already older than
+ * the retention window, inside a sub-second window; it is documented rather
+ * than locked against because `SqlDb` has no row-locking primitive.
+ *
+ * Intentionally **not** deleted here:
+ *
+ *   - `artifacts.storage_ref` blobs — only the metadata row goes; the blob
+ *     store is not consulted (the collector never wrote those blobs).
+ *   - `agent_runs` rows whose `id` is not an action in the tree — nothing
+ *     proves when they started.
+ *   - `ai_span_payloads.action_id` and `evidence_retrieval_refs` anchors —
+ *     those tables have their own `expires_at` retention.
+ *   - `eval_cases`, `eval_runs`, `eval_case_results` — curated fixtures,
+ *     never retention-bound.
+ */
+
+import type { SqlDb, SqlStatement } from "./sql-db";
+
+export interface ActionGraphRetentionOptions {
+	/** Retention window; trees whose newest action is older than this expire. */
+	retentionHours: number;
+	/** Clock override for tests. Defaults to `Date.now`. */
+	now?: () => number;
+	/**
+	 * Upper bound on actions deleted per batch/transaction. Also the largest
+	 * tree the sweep will delete; bigger trees are retained and reported.
+	 * Defaults to 500.
+	 */
+	maxActionsPerBatch?: number;
+	/** Upper bound on trees per batch (bounds statements per transaction). Defaults to 25. */
+	maxTreesPerBatch?: number;
+	/** Upper bound on batches per invocation. Defaults to 10. */
+	maxBatches?: number;
+}
+
+/** Per-table delete counts for one `purgeExpiredActionGraph` call. */
+export interface ActionGraphPurgeSummary {
+	actions: number;
+	agent_runs: number;
+	tool_calls: number;
+	retrieval_events: number;
+	eval_results: number;
+	artifacts: number;
+	/** Whole trees deleted. */
+	trees: number;
+	/** Batches (transactions) executed. */
+	batches: number;
+	/** `true` when `maxBatches` was hit while deletable trees remained. */
+	truncated: boolean;
+	/**
+	 * Expired, otherwise eligible trees retained because they hold more than
+	 * `maxActionsPerBatch` actions. Capped at `OVERSIZED_REPORT_LIMIT`.
+	 */
+	oversized_trees: number;
+	/** Identities of the reported oversized trees, for operators. */
+	oversized: Array<{
+		project_id: string;
+		root_action_id: string;
+		actions: number;
+	}>;
+}
+
+const DEFAULT_MAX_ACTIONS_PER_BATCH = 500;
+const DEFAULT_MAX_TREES_PER_BATCH = 25;
+const DEFAULT_MAX_BATCHES = 10;
+/** How many oversized trees one invocation lists; keeps the log line bounded. */
+export const OVERSIZED_REPORT_LIMIT = 20;
+
+/**
+ * Tree eligibility for the tree identified by the SQL expressions
+ * `project` / `root`. The DELETEs pass `?` placeholders (bound through
+ * `treeEligibleBinds`); the candidate query passes the grouped columns.
+ * Using the same text in both places means the decision is re-made,
+ * unchanged, inside the deleting transaction.
+ */
+const treeEligibleSql = (project: string, root: string, cutoff: string) => `
+	NOT EXISTS (
+	  SELECT 1 FROM actions t
+	  WHERE t.project_id = ${project} AND t.root_action_id = ${root}
+	    AND (t.started_at >= ${cutoff} OR t.ended_at IS NULL)
+	)
+	AND NOT EXISTS (
+	  SELECT 1 FROM actions t
+	  JOIN agent_runs r ON r.project_id = t.project_id AND r.id = t.agent_run_id
+	  WHERE t.project_id = ${project} AND t.root_action_id = ${root}
+	    AND r.status = 'running'
+	)
+	AND NOT EXISTS (
+	  SELECT 1 FROM actions t
+	  JOIN eval_cases c
+	    ON c.project_id = t.project_id
+	   AND (c.source_action_id = t.id OR c.source_agent_run_id = t.agent_run_id)
+	  WHERE t.project_id = ${project} AND t.root_action_id = ${root}
+	)
+	AND NOT EXISTS (
+	  SELECT 1 FROM actions t
+	  JOIN tool_calls tc ON tc.project_id = t.project_id AND tc.action_id = t.id
+	  JOIN eval_cases c ON c.project_id = tc.project_id AND c.source_tool_call_id = tc.id
+	  WHERE t.project_id = ${project} AND t.root_action_id = ${root}
+	)`;
+
+/** Eligibility with every tree reference bound; pair with `treeEligibleBinds`. */
+const TREE_ELIGIBLE_SQL = treeEligibleSql("?", "?", "?");
+
+/** Binds for `TREE_ELIGIBLE_SQL`, in placeholder order. */
+const treeEligibleBinds = (
+	projectId: string,
+	rootActionId: string,
+	cutoff: string,
+): unknown[] => [
+	projectId,
+	rootActionId,
+	cutoff,
+	projectId,
+	rootActionId,
+	projectId,
+	rootActionId,
+	projectId,
+	rootActionId,
+];
+
+/**
+ * Candidate trees, oldest first. The WHERE keeps the scan to expired rows
+ * (served by `idx_actions_started_at`); eligibility is decided per tree in
+ * HAVING over the whole tree, which — because eligible trees contain no
+ * fresh action — also makes `COUNT(*)` the full tree size.
+ *
+ * `sizeOp` is `<=` for deletable trees and `>` for oversized reporting.
+ * Binds: cutoff, size cap, cutoff (inside the eligibility test), limit.
+ */
+const candidateTreesSql = (sizeOp: "<=" | ">") => `
+	SELECT a.project_id, a.root_action_id, COUNT(*) AS action_count,
+	       MIN(a.started_at) AS oldest_started_at
+	FROM actions a
+	WHERE a.started_at < ?
+	GROUP BY a.project_id, a.root_action_id
+	HAVING COUNT(*) ${sizeOp} ?
+	   AND ${treeEligibleSql("a.project_id", "a.root_action_id", "?")}
+	ORDER BY oldest_started_at ASC
+	LIMIT ?
+`;
+
+const SELECT_DELETABLE_TREES_SQL = candidateTreesSql("<=");
+const SELECT_OVERSIZED_TREES_SQL = candidateTreesSql(">");
+
+interface CandidateTreeRow {
+	project_id: string;
+	root_action_id: string;
+	/** D1 returns numbers; pg returns BIGINT as string unless type parsers are configured. */
+	action_count: number | string;
+}
+
+interface CandidateTree {
+	projectId: string;
+	rootActionId: string;
+	actions: number;
+}
+
+/** Tables keyed by `action_id`, deleted before the spine. */
+const LEAF_TABLES = [
+	"tool_calls",
+	"retrieval_events",
+	"eval_results",
+	"artifacts",
+] as const;
+
+type LeafTable = (typeof LEAF_TABLES)[number];
+type CountedTable = LeafTable | "agent_runs" | "actions";
+
+const emptySummary = (): ActionGraphPurgeSummary => ({
+	actions: 0,
+	agent_runs: 0,
+	tool_calls: 0,
+	retrieval_events: 0,
+	eval_results: 0,
+	artifacts: 0,
+	trees: 0,
+	batches: 0,
+	truncated: false,
+	oversized_trees: 0,
+	oversized: [],
+});
+
+/** Cutoff as the same ISO text shape the collector writes to `started_at`. */
+export const actionRetentionCutoff = (
+	retentionHours: number,
+	nowMs: number = Date.now(),
+): string => new Date(nowMs - retentionHours * 60 * 60 * 1000).toISOString();
+
+const selectTrees = async (
+	db: SqlDb,
+	sql: string,
+	cutoff: string,
+	sizeCap: number,
+	limit: number,
+): Promise<CandidateTree[]> => {
+	const { results } = await db
+		.prepare(sql)
+		.bind(cutoff, sizeCap, cutoff, limit)
+		.all<CandidateTreeRow>();
+	return results.map((row) => ({
+		projectId: row.project_id,
+		rootActionId: row.root_action_id,
+		actions: Number(row.action_count),
+	}));
+};
+
+/**
+ * Greedy pack of whole trees (already ordered oldest first) into one batch
+ * without exceeding `maxActions`. Every candidate fits on its own because
+ * the SELECT capped tree size at `maxActions`.
+ */
+const packBatch = (
+	candidates: readonly CandidateTree[],
+	maxActions: number,
+): CandidateTree[] => {
+	const batch: CandidateTree[] = [];
+	let used = 0;
+	for (const tree of candidates) {
+		if (batch.length > 0 && used + tree.actions > maxActions) break;
+		batch.push(tree);
+		used += tree.actions;
+	}
+	return batch;
+};
+
+/**
+ * Purge expired action trees. Safe to call repeatedly: a second call right
+ * after the first finds no deletable trees and changes nothing.
+ */
+export async function purgeExpiredActionGraph(
+	db: SqlDb,
+	options: ActionGraphRetentionOptions,
+): Promise<ActionGraphPurgeSummary> {
+	const maxActions = Math.max(
+		1,
+		options.maxActionsPerBatch ?? DEFAULT_MAX_ACTIONS_PER_BATCH,
+	);
+	const maxTrees = Math.max(
+		1,
+		options.maxTreesPerBatch ?? DEFAULT_MAX_TREES_PER_BATCH,
+	);
+	const maxBatches = Math.max(1, options.maxBatches ?? DEFAULT_MAX_BATCHES);
+	const nowMs = (options.now ?? Date.now)();
+	const cutoff = actionRetentionCutoff(options.retentionHours, nowMs);
+
+	const summary = emptySummary();
+	let exhausted = false;
+
+	for (let batch = 0; batch < maxBatches && !exhausted; batch += 1) {
+		const candidates = await selectTrees(
+			db,
+			SELECT_DELETABLE_TREES_SQL,
+			cutoff,
+			maxActions,
+			maxTrees,
+		);
+		if (candidates.length === 0) {
+			exhausted = true;
+			break;
+		}
+		const trees = packBatch(candidates, maxActions);
+		summary.batches += 1;
+		const deleted = await deleteTrees(db, trees, cutoff);
+		for (const table of LEAF_TABLES) summary[table] += deleted[table];
+		summary.agent_runs += deleted.agent_runs;
+		summary.actions += deleted.actions;
+		summary.trees += deleted.trees;
+		// Fewer candidates than asked for and all of them packed: nothing left.
+		exhausted =
+			candidates.length < maxTrees && trees.length === candidates.length;
+	}
+
+	if (!exhausted) {
+		const remaining = await selectTrees(
+			db,
+			SELECT_DELETABLE_TREES_SQL,
+			cutoff,
+			maxActions,
+			1,
+		);
+		summary.truncated = remaining.length > 0;
+	}
+
+	const oversized = await selectTrees(
+		db,
+		SELECT_OVERSIZED_TREES_SQL,
+		cutoff,
+		maxActions,
+		OVERSIZED_REPORT_LIMIT,
+	);
+	summary.oversized_trees = oversized.length;
+	summary.oversized = oversized.map((tree) => ({
+		project_id: tree.projectId,
+		root_action_id: tree.rootActionId,
+		actions: tree.actions,
+	}));
+
+	return summary;
+}
+
+type BatchCounts = Record<CountedTable, number> & { trees: number };
+
+/**
+ * Delete the given trees in one `SqlDb.batch`: for each tree, its four leaf
+ * tables, then `agent_runs`, then the spine, every statement scoped by
+ * `project_id` and the tree and guarded by the eligibility recheck.
+ */
+async function deleteTrees(
+	db: SqlDb,
+	trees: readonly CandidateTree[],
+	cutoff: string,
+): Promise<BatchCounts> {
+	const statements: SqlStatement[] = [];
+	const owners: Array<{ table: CountedTable; tree: number }> = [];
+
+	trees.forEach(({ projectId, rootActionId }, treeIndex) => {
+		const guard = treeEligibleBinds(projectId, rootActionId, cutoff);
+		const push = (table: CountedTable, stmt: SqlStatement) => {
+			statements.push(stmt);
+			owners.push({ table, tree: treeIndex });
+		};
+		for (const table of LEAF_TABLES) {
+			push(
+				table,
+				db
+					.prepare(
+						`DELETE FROM ${table}
+						 WHERE project_id = ?
+						   AND action_id IN (
+						     SELECT id FROM actions WHERE project_id = ? AND root_action_id = ?
+						   )
+						   AND ${TREE_ELIGIBLE_SQL}`,
+					)
+					.bind(projectId, projectId, rootActionId, ...guard),
+			);
+		}
+		// `agent_runs.id` matches the run's root `actions.id` (sub-agent runs
+		// match a nested action), so only runs anchored in this tree go.
+		push(
+			"agent_runs",
+			db
+				.prepare(
+					`DELETE FROM agent_runs
+					 WHERE project_id = ?
+					   AND id IN (
+					     SELECT id FROM actions WHERE project_id = ? AND root_action_id = ?
+					   )
+					   AND ${TREE_ELIGIBLE_SQL}`,
+				)
+				.bind(projectId, projectId, rootActionId, ...guard),
+		);
+		push(
+			"actions",
+			db
+				.prepare(
+					`DELETE FROM actions
+					 WHERE project_id = ? AND root_action_id = ?
+					   AND ${TREE_ELIGIBLE_SQL}`,
+				)
+				.bind(projectId, rootActionId, ...guard),
+		);
+	});
+
+	const results = await db.batch(statements);
+	const counts: BatchCounts = {
+		tool_calls: 0,
+		retrieval_events: 0,
+		eval_results: 0,
+		artifacts: 0,
+		agent_runs: 0,
+		actions: 0,
+		trees: 0,
+	};
+	const spineDeleted = new Set<number>();
+	results.forEach((result, index) => {
+		const owner = owners[index];
+		if (!owner) return;
+		const changes = result?.meta?.changes ?? 0;
+		counts[owner.table] += changes;
+		if (owner.table === "actions" && changes > 0) spineDeleted.add(owner.tree);
+	});
+	counts.trees = spineDeleted.size;
+	return counts;
+}

package/src/lib/actions-store.ts

@@ -55,8 +55,7 @@ export class ActionStore {
 					tool_call_id, prompt_version, model_name, provider, total_cost_usd,
 					attrs_json
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
-					project_id = excluded.project_id,
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					root_action_id = excluded.root_action_id,
 					caused_by_action_id = excluded.caused_by_action_id,
 					actor_type = excluded.actor_type,
@@ -119,8 +118,7 @@ export class ActionStore {
 					autonomy_level, status, error_message, total_cost_usd,
 					total_duration_ms, metadata_json
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
-					project_id = excluded.project_id,
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					agent_id = excluded.agent_id,
 					agent_name = excluded.agent_name,
 					agent_version = excluded.agent_version,
@@ -160,9 +158,8 @@ export class ActionStore {
 					mcp_audit_json, mutation_before_json, mutation_after_json,
 					mutation_diff_json, mutation_artifact_id
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					action_id = excluded.action_id,
-					project_id = excluded.project_id,
 					tool_name = excluded.tool_name,
 					args_hash = excluded.args_hash,
 					result_hash = excluded.result_hash,
@@ -205,9 +202,8 @@ export class ActionStore {
 					id, action_id, project_id, retriever_name, query_hash, documents_json,
 					total_results, max_relevance_score, duration_ms
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					action_id = excluded.action_id,
-					project_id = excluded.project_id,
 					retriever_name = excluded.retriever_name,
 					query_hash = excluded.query_hash,
 					documents_json = excluded.documents_json,
@@ -236,9 +232,8 @@ export class ActionStore {
 					id, action_id, project_id, evaluator_name, evaluator_version, score,
 					passed, reasoning, rubric_json
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					action_id = excluded.action_id,
-					project_id = excluded.project_id,
 					evaluator_name = excluded.evaluator_name,
 					evaluator_version = excluded.evaluator_version,
 					score = excluded.score,
@@ -267,9 +262,8 @@ export class ActionStore {
 					id, action_id, project_id, artifact_name, artifact_type, storage_ref,
 					size_bytes, sha256_hash, content_preview
 				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
-				ON CONFLICT(id) DO UPDATE SET
+				ON CONFLICT(project_id, id) DO UPDATE SET
 					action_id = excluded.action_id,
-					project_id = excluded.project_id,
 					artifact_name = excluded.artifact_name,
 					artifact_type = excluded.artifact_type,
 					storage_ref = excluded.storage_ref,

package/src/lib/ai-store/calls.ts

@@ -97,7 +97,7 @@ export async function getAICallsOverview(
         SUM(total_cost_usd) as totalCostUsd,
         SUM(prompt_tokens) as totalPromptTokens,
         SUM(completion_tokens) as totalCompletionTokens,
-        SUM(is_error) as errorCalls
+        SUM(CASE WHEN is_error THEN 1 ELSE 0 END) as errorCalls
       FROM ai_calls WHERE project_id = ? AND received_at >= ${dialect.sinceHours("?")}
       ${options.service ? "AND service_name = ?" : ""}
     `;
@@ -124,7 +124,7 @@ export async function getAICallsOverview(
 		completionTokens: row.completion_tokens,
 		totalCostUsd: row.total_cost_usd,
 		latencyMs: row.latency_ms,
-		isError: row.is_error === 1,
+		isError: row.is_error === 1 || row.is_error === true,
 		errorMessage: row.error_message,
 		occurredAt: row.occurred_at,
 		receivedAt: row.received_at,

package/src/lib/ai-store/sessions.ts

@@ -43,7 +43,7 @@ export async function listAISessions(
         COUNT(DISTINCT s.trace_id) AS trace_count
       FROM ai_span_payloads p
       INNER JOIN telemetry_spans s
-        ON s.trace_id = p.trace_id AND s.span_id = p.span_id
+        ON s.project_id = p.project_id AND s.trace_id = p.trace_id AND s.span_id = p.span_id
       WHERE p.project_id = ?
         AND p.session_id IS NOT NULL
         AND p.received_at >= ${dialect.sinceHours("?")}
@@ -118,7 +118,7 @@ export async function getAISessionDetail(
         p.user_id             AS user_id
       FROM ai_span_payloads p
       INNER JOIN telemetry_spans s
-        ON s.trace_id = p.trace_id AND s.span_id = p.span_id
+        ON s.project_id = p.project_id AND s.trace_id = p.trace_id AND s.span_id = p.span_id
       WHERE p.project_id = ? AND p.session_id = ?
       ORDER BY s.start_time ASC
       LIMIT 1000
@@ -177,7 +177,7 @@ async function loadSessionPreviews(
       SELECT p.session_id, p.input_json, s.start_time
       FROM ai_span_payloads p
       INNER JOIN telemetry_spans s
-        ON s.trace_id = p.trace_id AND s.span_id = p.span_id
+        ON s.project_id = p.project_id AND s.trace_id = p.trace_id AND s.span_id = p.span_id
       WHERE p.project_id = ?
         AND p.session_id IS NOT NULL
         AND p.session_id IN (${sessionIds.map(() => "?").join(", ")})

package/src/lib/ai-store/spans.ts

@@ -38,7 +38,7 @@ export async function getAISpansOverview(
         p.output_json         AS output_json
       FROM ai_span_payloads p
       INNER JOIN telemetry_spans s
-        ON s.trace_id = p.trace_id AND s.span_id = p.span_id
+        ON s.project_id = p.project_id AND s.trace_id = p.trace_id AND s.span_id = p.span_id
       WHERE p.project_id = ?
         AND p.received_at >= ${dialect.sinceHours("?")}
     `;

package/src/lib/ai-store/types.ts

@@ -42,7 +42,8 @@ export interface AICallRow {
 	completion_tokens: number | null;
 	total_cost_usd: number | null;
 	latency_ms: number | null;
-	is_error: number;
+	/** INTEGER 0/1 on D1; BOOLEAN on Postgres unless the host installs the D1-shaped type parsers. */
+	is_error: number | boolean;
 	error_message: string | null;
 	occurred_at: string;
 	received_at: string;

package/src/lib/alerts-store.test.ts

@@ -0,0 +1,153 @@
+/**
+ * Project scoping for alert rule deletion and webhook target validation,
+ * executed against the real migrated SQLite schema.
+ */
+
+import type { AlertRuleInput } from "@obsunified/types";
+import { describe, expect, it } from "vitest";
+import { AlertsStore } from "./alerts-store";
+import { ProjectsStore } from "./projects-store";
+import { createMigratedSqliteDb } from "./test-utils/node-sqlite-db";
+
+const input = (over: Partial<AlertRuleInput> = {}): AlertRuleInput => ({
+	name: "errors",
+	signal: "spans",
+	query: {},
+	threshold: 1,
+	windowMins: 5,
+	comparison: ">",
+	channels: [{ type: "webhook", url: "https://hooks.example.com/alert/abc" }],
+	enabled: true,
+	...over,
+});
+
+describe("AlertsStore.deleteRule", () => {
+	it("deletes state and evaluations only for a rule the project owns", async () => {
+		const db = createMigratedSqliteDb();
+		// alert_rules.project_id references projects(id) (migration 012).
+		const projects = new ProjectsStore(db);
+		const alphaProject = await projects.createProject({ name: "A", slug: "a" });
+		const betaProject = await projects.createProject({ name: "B", slug: "b" });
+		const store = new AlertsStore(db);
+		const alpha = await store.createRule(
+			alphaProject.id,
+			input({ name: "alpha" }),
+		);
+		const beta = await store.createRule(
+			betaProject.id,
+			input({ name: "beta" }),
+		);
+		for (const rule of [alpha, beta]) {
+			await store.transitionState(rule.id, rule.projectId, "firing", "t0");
+			await store.recordEvaluation(rule.id, rule.projectId, 5, "firing", true);
+		}
+		const count = async (table: string, ruleId: string) =>
+			(
+				await db
+					.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE rule_id = ?`)
+					.bind(ruleId)
+					.first<{ n: number }>()
+			)?.n;
+
+		// Wrong project: nothing is deleted, not even the child rows.
+		expect(await store.deleteRule(beta.id, alphaProject.id)).toBe(false);
+		expect(await store.getRule(beta.id, betaProject.id)).not.toBeNull();
+		expect(await count("alert_state", beta.id)).toBe(1);
+		expect(await count("alert_evaluations", beta.id)).toBe(1);
+
+		// Right project: the rule and its children go, beta's stay.
+		expect(await store.deleteRule(alpha.id, alphaProject.id)).toBe(true);
+		expect(await store.getRule(alpha.id, alphaProject.id)).toBeNull();
+		expect(await count("alert_state", alpha.id)).toBe(0);
+		expect(await count("alert_evaluations", alpha.id)).toBe(0);
+		expect(await count("alert_state", beta.id)).toBe(1);
+		expect(await count("alert_evaluations", beta.id)).toBe(1);
+		db.close();
+	});
+});
+
+describe("AlertsStore.validateInput webhook targets", () => {
+	const store = new AlertsStore(createMigratedSqliteDb());
+
+	it("accepts public https hooks and rejects internal or credentialed ones", () => {
+		expect(() => store.validateInput(input())).not.toThrow();
+		for (const url of [
+			"http://127.0.0.1:8080/hook",
+			"http://169.254.169.254/latest/meta-data/",
+			"http://localhost/hook",
+			"https://user:pw@hooks.example.com/alert",
+			"ftp://hooks.example.com/alert",
+		]) {
+			expect(
+				() =>
+					store.validateInput(input({ channels: [{ type: "webhook", url }] })),
+				url,
+			).toThrow(/channel\.url/);
+		}
+	});
+
+	it("permits private receivers when the store is told to", () => {
+		const permissive = new AlertsStore(createMigratedSqliteDb(), {
+			allowPrivateWebhookTargets: true,
+		});
+		const internal = input({
+			channels: [{ type: "webhook", url: "http://10.0.0.5:9093/hook" }],
+		});
+		expect(() => permissive.validateInput(internal)).not.toThrow();
+		expect(() => store.validateInput(internal)).toThrow(/not a public/);
+	});
+});
+
+describe("AlertsStore alert_state.notified (migration 049)", () => {
+	it("records a transition as undelivered, marks exactly that transition delivered, and scopes by project", async () => {
+		const db = createMigratedSqliteDb();
+		const projects = new ProjectsStore(db);
+		const alpha = await projects.createProject({ name: "A", slug: "a" });
+		const beta = await projects.createProject({ name: "B", slug: "b" });
+		const store = new AlertsStore(db);
+		const rule = await store.createRule(alpha.id, input());
+
+		const t1 = "2026-05-31T00:00:00.000Z";
+		await store.transitionState(rule.id, alpha.id, "firing", t1);
+		expect(await store.getState(rule.id, alpha.id)).toMatchObject({
+			current_state: "firing",
+			last_state_change: t1,
+			notified: 0,
+		});
+		// Another project cannot read or acknowledge this rule's state.
+		expect(await store.getState(rule.id, beta.id)).toBeNull();
+		expect(await store.markNotified(rule.id, beta.id, "firing", t1)).toBe(
+			false,
+		);
+
+		// A stale acknowledgement (different state or timestamp) is ignored.
+		expect(await store.markNotified(rule.id, alpha.id, "ok", t1)).toBe(false);
+		expect(
+			await store.markNotified(
+				rule.id,
+				alpha.id,
+				"firing",
+				"2026-01-01T00:00:00.000Z",
+			),
+		).toBe(false);
+		expect((await store.getState(rule.id, alpha.id))?.notified).toBe(0);
+
+		expect(await store.markNotified(rule.id, alpha.id, "firing", t1)).toBe(
+			true,
+		);
+		expect((await store.getState(rule.id, alpha.id))?.notified).toBe(1);
+		// Idempotent: already delivered → no row changed.
+		expect(await store.markNotified(rule.id, alpha.id, "firing", t1)).toBe(
+			false,
+		);
+
+		// The next transition starts a fresh outstanding notification.
+		const t2 = "2026-05-31T01:00:00.000Z";
+		await store.transitionState(rule.id, alpha.id, "ok", t2);
+		expect(await store.getState(rule.id, alpha.id)).toMatchObject({
+			current_state: "ok",
+			last_state_change: t2,
+			notified: 0,
+		});
+	});
+});