dineway 0.1.49 → 0.2.0

package/dist/hitl-Hw1RmWOq.mjs

@@ -0,0 +1,677 @@
+import { i as encodeCursor, r as decodeCursor } from "./types-Dq1qT19x.mjs";
+import { i as parseSiteBriefingScope } from "./briefing-CawZ59CY.mjs";
+import { ulid } from "ulidx";
+import { Role } from "@dineway-ai/auth";
+
+//#region src/database/repositories/entity-aliases.ts
+const WHITESPACE_PATTERN = /\s+/g;
+function isResolvableEntityType(value) {
+	return value === "content" || value === "collection" || value === "plugin" || value === "taxonomy" || value === "menu";
+}
+function mapEntityAlias(row) {
+	if (!isResolvableEntityType(row.entity_type)) throw new Error(`Invalid entity alias type: ${row.entity_type}`);
+	return {
+		id: row.id,
+		entityType: row.entity_type,
+		collectionSlug: row.collection_slug,
+		entityId: row.entity_id,
+		alias: row.alias,
+		normalizedAlias: row.normalized_alias,
+		createdAt: row.created_at
+	};
+}
+function normalizeEntityAlias(value) {
+	return value.trim().toLowerCase().replace(WHITESPACE_PATTERN, " ");
+}
+var EntityAliasRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const normalizedAlias = normalizeEntityAlias(input.alias);
+		await this.db.insertInto("_dineway_entity_aliases").values({
+			id,
+			entity_type: input.entityType,
+			collection_slug: input.collectionSlug ?? null,
+			entity_id: input.entityId,
+			alias: input.alias,
+			normalized_alias: normalizedAlias
+		}).execute();
+		return mapEntityAlias(await this.db.selectFrom("_dineway_entity_aliases").selectAll().where("id", "=", id).executeTakeFirstOrThrow());
+	}
+	async findByNormalizedAlias(input) {
+		const limit = Math.min(Math.max(input.limit ?? 10, 1), 50);
+		const collectionSlug = input.collectionSlug;
+		let query = this.db.selectFrom("_dineway_entity_aliases").selectAll().where("normalized_alias", "=", input.normalizedAlias);
+		if (input.entityTypes && input.entityTypes.length > 0) query = query.where("entity_type", "in", input.entityTypes);
+		if (collectionSlug) query = query.where((eb) => eb.or([eb("collection_slug", "is", null), eb("collection_slug", "=", collectionSlug)]));
+		return (await query.orderBy("created_at", "desc").limit(limit).execute()).map(mapEntityAlias);
+	}
+};
+
+//#endregion
+//#region src/database/repositories/hitl-requests.ts
+const HITL_REQUEST_STATUSES = [
+	"pending",
+	"approved",
+	"rejected"
+];
+const HITL_REQUEST_PRIORITIES = [
+	"low",
+	"normal",
+	"high",
+	"urgent"
+];
+var HitlRequestRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_hitl_requests").values(toInsertableHitlRequest(id, input, now)).execute();
+		const request = await this.findById(id);
+		if (!request) throw new Error("Failed to create HITL request");
+		return request;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_hitl_requests").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToHitlRequest(row) : null;
+	}
+	async list(query = {}) {
+		const limit = clampLimit$1(query.limit);
+		const rows = await this.queryRows(query).execute();
+		const items = rows.slice(0, limit).map(rowToHitlRequest);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async resolve(id, input) {
+		const resolvedAt = input.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		const result = await this.db.updateTable("_dineway_hitl_requests").set({
+			status: input.decision,
+			resolved_by_actor_type: input.resolvedByActorType,
+			resolved_by_actor_id: input.resolvedByActorId,
+			resolved_auth_metadata: jsonStringOrNull(input.resolvedAuthMetadata),
+			review_note: input.reviewNote ?? null,
+			resolved_at: resolvedAt,
+			updated_at: resolvedAt
+		}).where("id", "=", id).where("status", "=", "pending").executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	queryRows(query) {
+		const limit = clampLimit$1(query.limit);
+		let q = this.db.selectFrom("_dineway_hitl_requests").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.scope) q = q.where("scope", "=", query.scope);
+		if (query.scopes && query.scopes.length > 0) q = q.where("scope", "in", query.scopes);
+		if (query.statuses && query.statuses.length > 0) q = q.where("status", "in", query.statuses);
+		if (query.priority) q = q.where("priority", "=", query.priority);
+		if (query.actionType) q = q.where("action_type", "=", query.actionType);
+		if (query.targetRefType) q = q.where("target_ref_type", "=", query.targetRefType);
+		if (query.targetRefId) q = q.where("target_ref_id", "=", query.targetRefId);
+		if (query.relatedAssignmentId) q = q.where("related_assignment_id", "=", query.relatedAssignmentId);
+		if (query.requestedByActorType && query.requestedByActorId) q = q.where("requested_by_actor_type", "=", query.requestedByActorType).where("requested_by_actor_id", "=", query.requestedByActorId);
+		if (query.participantActor) q = q.where("requested_by_actor_type", "=", query.participantActor.actorType).where("requested_by_actor_id", "=", query.participantActor.actorId);
+		if (query.since) q = q.where("updated_at", ">=", query.since);
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+};
+function toInsertableHitlRequest(id, input, now) {
+	return {
+		id,
+		scope: input.scope,
+		action_type: input.actionType,
+		status: "pending",
+		priority: input.priority ?? "normal",
+		title: input.title,
+		summary: input.summary ?? null,
+		risk_reason: input.riskReason,
+		review_payload: JSON.stringify(input.reviewPayload),
+		target_ref_type: input.targetRefType,
+		target_ref_id: input.targetRefId,
+		requested_by_actor_type: input.requestedByActorType,
+		requested_by_actor_id: input.requestedByActorId,
+		requested_auth_metadata: jsonStringOrNull(input.requestedAuthMetadata),
+		resolved_by_actor_type: null,
+		resolved_by_actor_id: null,
+		resolved_auth_metadata: null,
+		review_note: null,
+		metadata: jsonString$1(input.metadata),
+		related_assignment_id: input.relatedAssignmentId ?? null,
+		related_handoff_snapshot_id: input.relatedHandoffSnapshotId ?? null,
+		sla_due_at: input.slaDueAt ?? null,
+		created_at: now,
+		updated_at: now,
+		resolved_at: null
+	};
+}
+function rowToHitlRequest(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		actionType: row.action_type,
+		status: row.status,
+		priority: row.priority,
+		title: row.title,
+		summary: row.summary,
+		riskReason: row.risk_reason,
+		reviewPayload: parseRecord$2(row.review_payload),
+		targetRefType: row.target_ref_type,
+		targetRefId: row.target_ref_id,
+		requestedByActorType: row.requested_by_actor_type,
+		requestedByActorId: row.requested_by_actor_id,
+		requestedAuthMetadata: parseNullableRecord(row.requested_auth_metadata),
+		resolvedByActorType: row.resolved_by_actor_type,
+		resolvedByActorId: row.resolved_by_actor_id,
+		resolvedAuthMetadata: parseNullableRecord(row.resolved_auth_metadata),
+		reviewNote: row.review_note,
+		metadata: parseRecord$2(row.metadata),
+		relatedAssignmentId: row.related_assignment_id,
+		relatedHandoffSnapshotId: row.related_handoff_snapshot_id,
+		slaDueAt: row.sla_due_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		resolvedAt: row.resolved_at
+	};
+}
+function jsonString$1(value) {
+	return JSON.stringify(value ?? {});
+}
+function jsonStringOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord$2(value) {
+	if (!value) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$3(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function parseNullableRecord(value) {
+	if (!value) return null;
+	return parseRecord$2(value);
+}
+function isRecord$3(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit$1(limit) {
+	if (!limit || limit < 1) return 50;
+	return Math.min(limit, 100);
+}
+
+//#endregion
+//#region src/site-context/action-hash.ts
+async function buildStableActionHash(value) {
+	return sha256Hex(stableStringify(value));
+}
+function stableStringify(value) {
+	if (Array.isArray(value)) return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+	if (isRecord$2(value)) return `{${Object.entries(value).filter(([, entryValue]) => entryValue !== void 0).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+	return JSON.stringify(value ?? null);
+}
+function isRecord$2(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+async function sha256Hex(value) {
+	const buffer = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(value));
+	return Array.from(new Uint8Array(buffer), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+//#endregion
+//#region src/database/repositories/assignments.ts
+const ASSIGNMENT_ACTOR_TYPES = [
+	"user",
+	"api_token",
+	"system"
+];
+const ASSIGNMENT_STATUSES = [
+	"pending",
+	"accepted",
+	"in_progress",
+	"blocked",
+	"completed",
+	"declined",
+	"cancelled"
+];
+const ASSIGNMENT_PRIORITIES = [
+	"low",
+	"normal",
+	"high",
+	"urgent"
+];
+var AssignmentRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		const now = input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.insertInto("_dineway_assignments").values(toInsertableAssignment(id, input, now)).execute();
+		const assignment = await this.findById(id);
+		if (!assignment) throw new Error("Failed to create assignment");
+		return assignment;
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_assignments").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToAssignment(row) : null;
+	}
+	async list(query = {}) {
+		const limit = clampLimit(query.limit);
+		const rows = await this.queryRows(query).execute();
+		const items = rows.slice(0, limit).map(rowToAssignment);
+		const result = { items };
+		if (rows.length > limit && items.length > 0) {
+			const last = items.at(-1);
+			result.nextCursor = encodeCursor(last.createdAt, last.id);
+		}
+		return result;
+	}
+	async accept(id, input = {}) {
+		const value = input.acceptedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["pending"], {
+			status: "accepted",
+			assigned_to_actor_type: input.assignedToActorType ?? null,
+			assigned_to_actor_id: input.assignedToActorId ?? null,
+			accepted_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async start(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["accepted", "blocked"], {
+			status: "in_progress",
+			started_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async block(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["accepted", "in_progress"], {
+			status: "blocked",
+			blocked_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async complete(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, [
+			"pending",
+			"accepted",
+			"in_progress"
+		], {
+			status: "completed",
+			completed_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async decline(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, ["pending", "accepted"], {
+			status: "declined",
+			declined_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async cancel(id, input = {}) {
+		const value = input.at ?? (/* @__PURE__ */ new Date()).toISOString();
+		return this.transition(id, [
+			"pending",
+			"accepted",
+			"in_progress",
+			"blocked"
+		], {
+			status: "cancelled",
+			cancelled_at: value,
+			updated_at: value,
+			metadata: jsonString(input.metadata)
+		});
+	}
+	async linkHitlRequest(id, relatedHitlRequestId, at = (/* @__PURE__ */ new Date()).toISOString()) {
+		const result = await this.db.updateTable("_dineway_assignments").set({
+			related_hitl_request_id: relatedHitlRequestId,
+			updated_at: at
+		}).where("id", "=", id).executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+	queryRows(query) {
+		const limit = clampLimit(query.limit);
+		let q = this.db.selectFrom("_dineway_assignments").selectAll().orderBy("created_at", "desc").orderBy("id", "desc").limit(limit + 1);
+		if (query.scope) q = q.where("scope", "=", query.scope);
+		if (query.scopes && query.scopes.length > 0) q = q.where("scope", "in", query.scopes);
+		if (query.statuses && query.statuses.length > 0) q = q.where("status", "in", query.statuses);
+		if (query.priority) q = q.where("priority", "=", query.priority);
+		if (query.assignmentType) q = q.where("assignment_type", "=", query.assignmentType);
+		if (query.assignedToActorType && query.assignedToActorId) q = q.where("assigned_to_actor_type", "=", query.assignedToActorType).where("assigned_to_actor_id", "=", query.assignedToActorId);
+		if (query.assignedByActorType && query.assignedByActorId) q = q.where("assigned_by_actor_type", "=", query.assignedByActorType).where("assigned_by_actor_id", "=", query.assignedByActorId);
+		if (query.participantActor) q = q.where((eb) => eb.or([eb.and([eb("assigned_by_actor_type", "=", query.participantActor.actorType), eb("assigned_by_actor_id", "=", query.participantActor.actorId)]), eb.and([eb("assigned_to_actor_type", "=", query.participantActor.actorType), eb("assigned_to_actor_id", "=", query.participantActor.actorId)])]));
+		if (query.since) q = q.where("updated_at", ">=", query.since);
+		if (query.cursor) {
+			const decoded = decodeCursor(query.cursor);
+			if (decoded) q = q.where((eb) => eb.or([eb("created_at", "<", decoded.orderValue), eb.and([eb("created_at", "=", decoded.orderValue), eb("id", "<", decoded.id)])]));
+		}
+		return q;
+	}
+	async transition(id, validFrom, update) {
+		const result = await this.db.updateTable("_dineway_assignments").set(update).where("id", "=", id).where("status", "in", validFrom).executeTakeFirst();
+		if (Number(result.numUpdatedRows ?? 0) === 0) return null;
+		return this.findById(id);
+	}
+};
+function toInsertableAssignment(id, input, now) {
+	return {
+		id,
+		scope: input.scope,
+		assignment_type: input.assignmentType,
+		status: "pending",
+		priority: input.priority ?? "normal",
+		title: input.title,
+		summary: input.summary ?? null,
+		details: input.details ?? null,
+		assigned_by_actor_type: input.assignedByActorType,
+		assigned_by_actor_id: input.assignedByActorId,
+		assigned_to_actor_type: input.assignedToActorType ?? null,
+		assigned_to_actor_id: input.assignedToActorId ?? null,
+		metadata: jsonString(input.metadata),
+		related_handoff_snapshot_id: input.relatedHandoffSnapshotId ?? null,
+		related_hitl_request_id: input.relatedHitlRequestId ?? null,
+		due_at: input.dueAt ?? null,
+		created_at: now,
+		updated_at: now,
+		accepted_at: null,
+		started_at: null,
+		blocked_at: null,
+		completed_at: null,
+		declined_at: null,
+		cancelled_at: null
+	};
+}
+function rowToAssignment(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		assignmentType: row.assignment_type,
+		status: row.status,
+		priority: row.priority,
+		title: row.title,
+		summary: row.summary,
+		details: row.details,
+		assignedByActorType: row.assigned_by_actor_type,
+		assignedByActorId: row.assigned_by_actor_id,
+		assignedToActorType: row.assigned_to_actor_type,
+		assignedToActorId: row.assigned_to_actor_id,
+		metadata: parseRecord$1(row.metadata),
+		relatedHandoffSnapshotId: row.related_handoff_snapshot_id,
+		relatedHitlRequestId: row.related_hitl_request_id,
+		dueAt: row.due_at,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		acceptedAt: row.accepted_at,
+		startedAt: row.started_at,
+		blockedAt: row.blocked_at,
+		completedAt: row.completed_at,
+		declinedAt: row.declined_at,
+		cancelledAt: row.cancelled_at
+	};
+}
+function jsonString(value) {
+	return JSON.stringify(value ?? {});
+}
+function parseRecord$1(value) {
+	if (!value) return {};
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord$1(parsed) ? parsed : {};
+	} catch {
+		return {};
+	}
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function clampLimit(limit) {
+	if (!limit || limit < 1) return 50;
+	return Math.min(limit, 100);
+}
+
+//#endregion
+//#region src/database/repositories/handoff-snapshots.ts
+var HandoffSnapshotRepository = class {
+	constructor(db) {
+		this.db = db;
+	}
+	async create(input) {
+		const id = ulid();
+		await this.db.insertInto("_dineway_handoff_snapshots").values(toInsertableHandoffSnapshot(id, input)).execute();
+		return this.findById(id).then((snapshot) => {
+			if (!snapshot) throw new Error("Failed to create handoff snapshot");
+			return snapshot;
+		});
+	}
+	async findById(id) {
+		const row = await this.db.selectFrom("_dineway_handoff_snapshots").selectAll().where("id", "=", id).executeTakeFirst();
+		return row ? rowToHandoffSnapshot(row) : null;
+	}
+	async markResumed(id, resumedAt) {
+		const value = resumedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+		await this.db.updateTable("_dineway_handoff_snapshots").set({ resumed_at: value }).where("id", "=", id).execute();
+		return this.findById(id);
+	}
+};
+function toInsertableHandoffSnapshot(id, input) {
+	return {
+		id,
+		scope: input.scope,
+		actor_type: input.actorType,
+		actor_id: input.actorId,
+		auth_metadata: jsonOrNull(input.authMetadata),
+		objective: input.objective,
+		reasoning: input.reasoning,
+		key_findings: JSON.stringify(input.keyFindings ?? []),
+		touched_objects: JSON.stringify(input.touchedObjects ?? []),
+		pending_actions: JSON.stringify(input.pendingActions ?? []),
+		tool_evidence: JSON.stringify(input.toolEvidence ?? []),
+		confidence: input.confidence ?? null,
+		handoff_kind: input.handoffKind ?? "pause",
+		reference_type: input.referenceType ?? null,
+		reference_id: input.referenceId ?? null,
+		created_at: input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+		resumed_at: null
+	};
+}
+function rowToHandoffSnapshot(row) {
+	return {
+		id: row.id,
+		scope: row.scope,
+		actorType: row.actor_type,
+		actorId: row.actor_id,
+		authMetadata: parseRecord(row.auth_metadata),
+		objective: row.objective,
+		reasoning: row.reasoning,
+		keyFindings: parseArray(row.key_findings),
+		touchedObjects: parseArray(row.touched_objects),
+		pendingActions: parseArray(row.pending_actions),
+		toolEvidence: parseArray(row.tool_evidence),
+		confidence: row.confidence,
+		handoffKind: row.handoff_kind,
+		referenceType: row.reference_type,
+		referenceId: row.reference_id,
+		createdAt: row.created_at,
+		resumedAt: row.resumed_at
+	};
+}
+function jsonOrNull(value) {
+	return value ? JSON.stringify(value) : null;
+}
+function parseRecord(value) {
+	if (!value) return null;
+	try {
+		const parsed = JSON.parse(value);
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function parseArray(value) {
+	if (!value) return [];
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed.filter((_item) => true) : [];
+	} catch {
+		return [];
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+//#endregion
+//#region src/site-context/hitl.ts
+const HITL_REQUEST_VALID_FROM = { resolve: ["pending"] };
+var HitlRequestService = class {
+	repository;
+	assignments;
+	constructor(db) {
+		this.db = db;
+		this.repository = new HitlRequestRepository(db);
+		this.assignments = new AssignmentRepository(db);
+	}
+	async create(actor, input) {
+		parseSiteBriefingScope(input.scope);
+		const assignment = input.relatedAssignmentId ? await this.assignments.findById(input.relatedAssignmentId) : null;
+		if (input.relatedAssignmentId && !assignment) throw new Error(`Assignment not found: ${input.relatedAssignmentId}`);
+		if (assignment) {
+			this.assertRelatedAssignmentReadable(assignment, actor);
+			if (assignment.scope !== input.scope) throw new Error("Related assignment scope must match the HITL request scope.");
+			if (assignment.relatedHitlRequestId) throw new Error(`Assignment ${assignment.id} is already linked to HITL request ${assignment.relatedHitlRequestId}.`);
+		}
+		if (input.relatedHandoffSnapshotId) {
+			const snapshot = await new HandoffSnapshotRepository(this.db).findById(input.relatedHandoffSnapshotId);
+			if (!snapshot) throw new Error(`Handoff snapshot not found: ${input.relatedHandoffSnapshotId}`);
+			this.assertRelatedHandoffSnapshotReadable(snapshot, actor);
+			if (snapshot.scope !== input.scope) throw new Error("Related handoff snapshot scope must match the HITL request scope.");
+		}
+		const request = await this.repository.create({
+			scope: input.scope,
+			actionType: input.actionType,
+			title: input.title,
+			summary: input.summary,
+			riskReason: input.riskReason,
+			reviewPayload: input.reviewPayload,
+			targetRefType: input.targetRefType,
+			targetRefId: input.targetRefId,
+			requestedByActorType: actor.actorType,
+			requestedByActorId: actor.actorId,
+			requestedAuthMetadata: actor.authMetadata,
+			priority: input.priority,
+			metadata: input.metadata,
+			relatedAssignmentId: input.relatedAssignmentId,
+			relatedHandoffSnapshotId: input.relatedHandoffSnapshotId,
+			slaDueAt: input.slaDueAt,
+			createdAt: input.createdAt
+		});
+		if (assignment) {
+			if (!await this.assignments.linkHitlRequest(assignment.id, request.id, request.createdAt)) throw new Error(`Failed to link assignment ${assignment.id} to HITL request ${request.id}.`);
+		}
+		return request;
+	}
+	async get(id, actor) {
+		const request = await this.repository.findById(id);
+		if (!request) return null;
+		this.assertReadable(request, actor);
+		return request;
+	}
+	async list(actor, input = {}) {
+		return this.repository.list(this.buildListQuery(actor, input));
+	}
+	async resolve(input) {
+		const request = await this.loadExisting(input.id);
+		this.assertResolver(input.actor);
+		this.assertReadable(request, input.actor);
+		this.assertValidAction("resolve", request.status);
+		const resolved = await this.repository.resolve(request.id, {
+			decision: input.decision,
+			resolvedByActorType: input.actor.actorType,
+			resolvedByActorId: input.actor.actorId,
+			resolvedAuthMetadata: input.actor.authMetadata,
+			reviewNote: input.reviewNote,
+			resolvedAt: input.at
+		});
+		if (!resolved) throw new Error(`Failed to resolve HITL request ${request.id}.`);
+		return resolved;
+	}
+	buildListQuery(actor, input) {
+		const query = {
+			scope: input.scope,
+			scopes: input.scopes,
+			statuses: input.statuses,
+			priority: input.priority,
+			actionType: input.actionType,
+			targetRefType: input.targetRefType,
+			targetRefId: input.targetRefId,
+			relatedAssignmentId: input.relatedAssignmentId,
+			since: input.since,
+			limit: input.limit,
+			cursor: input.cursor
+		};
+		if (isHitlSupervisor(actor.userRole)) return query;
+		return {
+			...query,
+			requestedByActorType: actor.actorType,
+			requestedByActorId: actor.actorId
+		};
+	}
+	async loadExisting(id) {
+		const request = await this.repository.findById(id);
+		if (!request) throw new Error(`HITL request not found: ${id}`);
+		return request;
+	}
+	assertReadable(request, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (request.requestedByActorType === actor.actorType && request.requestedByActorId === actor.actorId) return;
+		throw new Error("Insufficient permissions to read this HITL request.");
+	}
+	assertResolver(actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		throw new Error("HITL requests may only be resolved by an editor or admin.");
+	}
+	assertRelatedAssignmentReadable(assignment, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (matchesActor(assignment.assignedByActorType, assignment.assignedByActorId, actor) || matchesActor(assignment.assignedToActorType, assignment.assignedToActorId, actor)) return;
+		throw new Error("Insufficient permissions to link this assignment to a HITL request.");
+	}
+	assertRelatedHandoffSnapshotReadable(snapshot, actor) {
+		if (isHitlSupervisor(actor.userRole)) return;
+		if (matchesActor(snapshot.actorType, snapshot.actorId, actor)) return;
+		throw new Error("Insufficient permissions to link this handoff snapshot to a HITL request.");
+	}
+	assertValidAction(action, status) {
+		const validFrom = HITL_REQUEST_VALID_FROM[action];
+		if (!validFrom.includes(status)) throw new Error(`Cannot ${action} a HITL request in status "${status}". Valid statuses: ${validFrom.join(", ")}.`);
+	}
+};
+function isHitlSupervisor(role) {
+	return role >= Role.EDITOR;
+}
+function matchesActor(actorType, actorId, actor) {
+	return actorType === actor.actorType && actorId === actor.actorId;
+}
+
+//#endregion
+export { ASSIGNMENT_STATUSES as a, stableStringify as c, HitlRequestRepository as d, EntityAliasRepository as f, ASSIGNMENT_PRIORITIES as i, HITL_REQUEST_PRIORITIES as l, HandoffSnapshotRepository as n, AssignmentRepository as o, normalizeEntityAlias as p, ASSIGNMENT_ACTOR_TYPES as r, buildStableActionHash as s, HitlRequestService as t, HITL_REQUEST_STATUSES as u };

package/dist/{hitl-requests-7NlzVeUA.mjs → hitl-requests-B4Vbcmaq.mjs}

@@ -1,5 +1,5 @@
-import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-CSMffP6q.mjs";
-import { n as HitlRequestService } from "./site-context-C8Az_P_I.mjs";
+import { t as HitlRequestService } from "./hitl-Hw1RmWOq.mjs";
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-BMsUnIAw.mjs";
 
 //#region src/api/handlers/hitl-requests.ts
 const HITL_NOT_FOUND_RE = /not found/i;

package/dist/{hitl-route-helpers-k---_H3-.mjs → hitl-route-helpers-hEVzvP8l.mjs}

@@ -1,7 +1,8 @@
-import { t as apiError } from "./error-DCSuUAZW.mjs";
-import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-CSMffP6q.mjs";
-import { t as WorkflowHitlCoordinator } from "./site-context-C8Az_P_I.mjs";
-import { T as resolveActorIdentity, p as logSiteActivitySafely } from "./activity-events-CwM7yxPW.mjs";
+import { t as apiError } from "./error-CytFlgcd.mjs";
+import { t as resolveActorIdentity } from "./actor-CrObAPV0.mjs";
+import { p as logSiteActivitySafely } from "./activity-events-y6eT8UW6.mjs";
+import { t as ExperimentalSiteContextWorkflowDisabledError } from "./experimental-workflows-BMsUnIAw.mjs";
+import { t as WorkflowHitlCoordinator } from "./site-context-DQiL8Fl5.mjs";
 import { Role } from "@dineway-ai/auth";
 
 //#region src/api/hitl-route-helpers.ts