reflet-sdk 0.6.8 → 0.7.0

package/dist/{sessions-panel-Dq5j1qcu.js → sessions-panel-DPhFYhbk.js}

@@ -1,9 +1,10 @@
-import { a as EDITORS, c as handoffFileSchema, d as sessionEvidenceSchema, f as sessionHandoffSchema, g as sessionSummarySchema, h as sessionSegmentSchema, l as sessionApiErrorSchema, m as sessionProposalSchema, n as DEVTOOLS_REQUEST_HEADER, p as sessionIdentitySchema, r as DEVTOOLS_ROUTE_BASE, s as analysisStatusSchema, t as DEVTOOLS_ENDPOINTS, u as sessionDetailSchema } from "./protocol-Cg_cI4xS.js";
-import { B as clip, D as MoreIcon, G as describeElement, K as getElementRect, M as TargetIcon, R as DEFAULT_WIDGET_LABELS, T as GripIcon, W as buildSelector, Y as redactUrl, Z as inspectReactElement, _ as matchesHotkey, a as uploadBlob, c as useFloatingPosition, g as isSubmitEnter, it as releaseCapture, j as Svg, l as onViewportChange, m as startsInWidget, o as ElementPicker, p as listenToKeydown, q as REDACT_ATTRIBUTE, tt as captureViewport, u as visibleViewport, w as CloseIcon } from "./submit-CafYVnCb.js";
+import { a as EDITORS, n as DEVTOOLS_REQUEST_HEADER, r as DEVTOOLS_ROUTE_BASE, t as DEVTOOLS_ENDPOINTS } from "./protocol-cJVVwnPe.js";
+import { B as clip, D as MoreIcon, G as describeElement, K as getElementRect, M as TargetIcon, R as DEFAULT_WIDGET_LABELS, T as GripIcon, W as buildSelector, Y as redactUrl, Z as inspectReactElement, _ as matchesHotkey, a as uploadBlob, c as useFloatingPosition, g as isSubmitEnter, it as releaseCapture, j as Svg, l as onViewportChange, m as startsInWidget, o as ElementPicker, p as listenToKeydown, q as REDACT_ATTRIBUTE, tt as captureViewport, u as visibleViewport, w as CloseIcon } from "./submit-CahCBj1P.js";
 import { t as REFLET_Z_INDEX } from "./z-index-CwokqVq_.js";
 import { z } from "zod";
 import { createContext, useContext, useEffect, useId, useLayoutEffect, useRef, useState, useSyncExternalStore } from "react";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { flushSync } from "react-dom";
 //#region src/devtools/client/notices.tsx
 const STATUS_VISIBLE_MS = 2400;
 const ACTION_VISIBLE_MS = 6e3;
@@ -82,10 +83,531 @@ function useRecorderSnapshot(recorder) {
 	return useSyncExternalStore(recorder.subscribe, recorder.getSnapshot, recorder.getSnapshot);
 }
 //#endregion
+//#region src/sessions/intention-protocol.ts
+const INTENTION_FIELDS = [
+	"need",
+	"observed",
+	"response",
+	"unknowns",
+	"setAside"
+];
+const INTENTION_CHANGE_KINDS = [
+	"precision",
+	"contradiction",
+	"constraint",
+	"solution",
+	"outcome"
+];
+const fieldValueSchema = z.union([z.string(), z.array(z.string())]);
+const intentionChangeSchema = z.object({
+	decision: z.enum([
+		"pending",
+		"accepted",
+		"rejected"
+	]),
+	evidenceIds: z.array(z.string()),
+	field: z.enum(INTENTION_FIELDS),
+	hypothesis: z.boolean(),
+	id: z.string(),
+	kind: z.enum(INTENTION_CHANGE_KINDS),
+	operation: z.enum([
+		"replace",
+		"add",
+		"remove"
+	]),
+	reason: z.string(),
+	segmentIds: z.array(z.string()),
+	value: z.string()
+});
+const appliedChangeSchema = z.object({
+	at: z.number(),
+	byName: z.string().nullable(),
+	fields: z.array(z.object({
+		after: fieldValueSchema,
+		before: fieldValueSchema,
+		field: z.enum(INTENTION_FIELDS)
+	})),
+	revision: z.number()
+});
+const sessionContributionSchema = z.object({
+	answers: z.array(z.object({
+		at: z.number(),
+		text: z.string()
+	})),
+	applied: z.array(appliedChangeSchema),
+	baseRevision: z.number(),
+	changes: z.array(intentionChangeSchema),
+	detachedAt: z.number().nullable(),
+	id: z.string(),
+	intentionId: z.string(),
+	needsShareConsent: z.boolean(),
+	origin: z.enum(["continuation", "attach"]),
+	question: z.string().nullable(),
+	sharedAt: z.number().nullable(),
+	stale: z.boolean(),
+	state: z.enum([
+		"recording",
+		"analyzing",
+		"ready",
+		"no_change",
+		"failed"
+	]),
+	verdict: z.object({
+		reason: z.string(),
+		segmentIds: z.array(z.string()),
+		status: z.enum([
+			"resolved",
+			"needs_work",
+			"insufficient"
+		])
+	}).nullable()
+});
+const continuedIntentionSchema = z.object({
+	id: z.string(),
+	need: z.string(),
+	observed: z.string(),
+	question: z.string().nullable(),
+	response: z.string().nullable(),
+	revision: z.number(),
+	sessionId: z.string(),
+	sessionTitle: z.string(),
+	setAside: z.array(z.string()),
+	unknowns: z.array(z.string()),
+	verification: z.object({
+		at: z.number(),
+		sessionId: z.string().nullable(),
+		status: z.enum(["works", "needs_work"])
+	}).nullable()
+});
+const sessionContinuationSchema = z.object({
+	contribution: sessionContributionSchema,
+	intention: continuedIntentionSchema.nullable()
+});
+const contributionQuoteSchema = z.object({
+	context: z.array(z.string()),
+	segmentId: z.string(),
+	startMs: z.number(),
+	text: z.string()
+});
+const intentionHistoryEntrySchema = z.object({
+	applied: z.array(appliedChangeSchema),
+	detachedAt: z.number().nullable(),
+	evidenceIds: z.array(z.string()),
+	extractsHidden: z.boolean(),
+	id: z.string(),
+	intentionId: z.string(),
+	origin: z.enum(["continuation", "attach"]),
+	quotes: z.array(contributionQuoteSchema),
+	session: z.object({
+		canOpen: z.boolean(),
+		id: z.string(),
+		startedAt: z.number(),
+		title: z.string()
+	})
+});
+const intentionSuggestionSchema = z.object({
+	intentionId: z.string(),
+	need: z.string(),
+	needsShareConsent: z.boolean(),
+	reason: z.string(),
+	sessionId: z.string(),
+	sessionTitle: z.string()
+});
+const lastHandoffSchema = z.object({
+	at: z.number(),
+	need: z.string(),
+	response: z.string().nullable(),
+	revision: z.number(),
+	unknowns: z.array(z.string()).nullable()
+});
+//#endregion
+//#region src/sessions/protocol.ts
+const SESSION_SURFACES = ["devtools", "app"];
+const SESSION_GAP_REASONS = [
+	"paused",
+	"hidden",
+	"interrupted",
+	"limit"
+];
+const SESSION_LIMIT_KINDS = [
+	"duration",
+	"segments",
+	"events",
+	"evidence",
+	"bytes"
+];
+const PROPOSAL_DECISIONS = [
+	"pending",
+	"kept",
+	"later",
+	"dismissed"
+];
+const EVIDENCE_TRIGGERS = [
+	"start",
+	"mark",
+	"navigation",
+	"select",
+	"manual"
+];
+const sessionLimitsSchema = z.object({
+	audioRetentionMs: z.number(),
+	maxDurationMs: z.number(),
+	maxEvents: z.number(),
+	maxEventsPerBatch: z.number(),
+	maxEvidence: z.number(),
+	maxImageBytes: z.number(),
+	maxLocalBufferBytes: z.number(),
+	maxSegmentBytes: z.number(),
+	maxSegmentMs: z.number(),
+	maxSegments: z.number(),
+	minAutoCaptureIntervalMs: z.number(),
+	warnBeforeLimitMs: z.number()
+});
+const sessionIdentitySchema = z.object({
+	analysisConfigured: z.boolean(),
+	limits: sessionLimitsSchema,
+	organizationId: z.string(),
+	organizationName: z.string(),
+	transcriptionConfigured: z.boolean(),
+	user: z.object({
+		email: z.string().nullable(),
+		id: z.string(),
+		name: z.string().nullable()
+	})
+});
+const analysisStatusSchema = z.object({
+	analyzedRevision: z.number().nullable(),
+	error: z.string().nullable(),
+	proposalCount: z.number().nullable(),
+	state: z.enum([
+		"idle",
+		"waiting",
+		"running",
+		"succeeded",
+		"failed"
+	]),
+	transcriptRevision: z.number(),
+	updatedAt: z.number().nullable()
+});
+const sessionSummarySchema = z.object({
+	analysis: analysisStatusSchema,
+	authorName: z.string().nullable(),
+	collection: z.enum([
+		"recording",
+		"paused",
+		"ended"
+	]),
+	counts: z.object({
+		evidence: z.number(),
+		failedSegments: z.number(),
+		handoffs: z.number(),
+		kept: z.number(),
+		pendingSegments: z.number(),
+		proposals: z.number(),
+		segments: z.number()
+	}),
+	durationMs: z.number(),
+	endedAt: z.number().nullable(),
+	id: z.string(),
+	isMine: z.boolean(),
+	startedAt: z.number(),
+	surface: z.enum(SESSION_SURFACES),
+	title: z.string(),
+	visibility: z.enum(["private", "team"])
+});
+const rectSchema = z.object({
+	height: z.number(),
+	width: z.number(),
+	x: z.number(),
+	y: z.number()
+});
+const elementRefSchema = z.object({
+	component: z.string().nullable(),
+	label: z.string(),
+	rect: rectSchema,
+	role: z.string().nullable(),
+	selector: z.string(),
+	source: z.string().nullable()
+});
+const frameSchema = z.object({
+	devicePixelRatio: z.number(),
+	scrollX: z.number(),
+	scrollY: z.number(),
+	title: z.string().nullable(),
+	url: z.string(),
+	viewportHeight: z.number(),
+	viewportWidth: z.number()
+});
+const pointerSchema = z.object({
+	x: z.number(),
+	y: z.number()
+});
+z.discriminatedUnion("kind", [
+	z.object({
+		atMs: z.number(),
+		frame: frameSchema,
+		kind: z.literal("navigation")
+	}),
+	z.object({
+		atMs: z.number(),
+		element: elementRefSchema,
+		frame: frameSchema,
+		kind: z.literal("click"),
+		pointer: pointerSchema.nullable()
+	}),
+	z.object({
+		atMs: z.number(),
+		durationMs: z.number(),
+		element: elementRefSchema,
+		frame: frameSchema,
+		kind: z.literal("dwell"),
+		pointer: pointerSchema
+	}),
+	z.object({
+		atMs: z.number(),
+		kind: z.literal("scroll"),
+		scrollX: z.number(),
+		scrollY: z.number()
+	}),
+	z.object({
+		atMs: z.number(),
+		devicePixelRatio: z.number(),
+		kind: z.literal("viewport"),
+		viewportHeight: z.number(),
+		viewportWidth: z.number()
+	}),
+	z.object({
+		atMs: z.number(),
+		element: elementRefSchema.nullable(),
+		evidenceClientKey: z.string().nullable(),
+		frame: frameSchema,
+		kind: z.literal("mark"),
+		note: z.string().nullable()
+	}),
+	z.object({
+		atMs: z.number(),
+		element: elementRefSchema,
+		evidenceClientKey: z.string().nullable(),
+		frame: frameSchema,
+		kind: z.literal("select"),
+		note: z.string().nullable()
+	})
+]);
+const sessionGapSchema = z.object({
+	endMs: z.number().nullable(),
+	reason: z.enum(SESSION_GAP_REASONS),
+	startMs: z.number()
+});
+const segmentContextSchema = z.object({
+	atMs: z.number(),
+	durationMs: z.number().nullable(),
+	element: elementRefSchema.nullable(),
+	evidenceId: z.string().nullable(),
+	evidenceMatch: z.enum(["exact", "approximate"]).nullable(),
+	evidenceOffsetMs: z.number().nullable(),
+	frame: frameSchema.nullable(),
+	kind: z.enum([
+		"mark",
+		"select",
+		"click",
+		"dwell",
+		"navigation",
+		"screenshot"
+	]),
+	label: z.string(),
+	pointer: pointerSchema.nullable(),
+	url: z.string().nullable()
+});
+const contextChoiceSchema = z.discriminatedUnion("kind", [
+	z.object({ kind: z.literal("auto") }),
+	z.object({ kind: z.literal("unknown") }),
+	z.object({
+		atMs: z.number(),
+		eventKind: z.enum([
+			"mark",
+			"select",
+			"click",
+			"dwell",
+			"navigation"
+		]),
+		kind: z.literal("event")
+	}),
+	z.object({
+		evidenceId: z.string(),
+		kind: z.literal("evidence")
+	})
+]);
+const contextOptionSchema = z.object({
+	choice: contextChoiceSchema,
+	item: segmentContextSchema,
+	selected: z.boolean()
+});
+const sessionSegmentSchema = z.object({
+	audioExpiresAt: z.number().nullable(),
+	context: z.array(segmentContextSchema),
+	contextAmbiguous: z.boolean(),
+	contextCorrectedAt: z.number().nullable(),
+	contextOrigin: z.enum([
+		"auto",
+		"human",
+		"unknown"
+	]),
+	endMs: z.number(),
+	hasAudio: z.boolean(),
+	id: z.string(),
+	language: z.string().nullable(),
+	revision: z.number(),
+	source: z.enum(["voice", "typed"]),
+	startMs: z.number(),
+	text: z.string(),
+	textOrigin: z.enum(["transcription", "human"]),
+	transcription: z.object({
+		attempts: z.number(),
+		error: z.string().nullable(),
+		state: z.enum([
+			"pending",
+			"running",
+			"done",
+			"empty",
+			"failed",
+			"expired"
+		])
+	})
+});
+const evidenceLinkSchema = z.object({
+	access: z.string(),
+	label: z.string(),
+	url: z.string()
+});
+const sessionEvidenceSchema = z.object({
+	atMs: z.number(),
+	capturedAtMs: z.number().nullable(),
+	element: elementRefSchema.nullable(),
+	frame: frameSchema.nullable(),
+	id: z.string(),
+	image: z.object({
+		height: z.number(),
+		url: z.string().nullable(),
+		width: z.number()
+	}).nullable(),
+	kind: z.enum(["screenshot", "link"]),
+	link: evidenceLinkSchema.nullable(),
+	missingReason: z.string().nullable(),
+	note: z.string().nullable(),
+	status: z.enum(["available", "missing"]),
+	trigger: z.enum(EVIDENCE_TRIGGERS)
+});
+const sessionProposalSchema = z.object({
+	attachment: z.object({
+		contributionId: z.string(),
+		intentionId: z.string(),
+		need: z.string()
+	}).nullable(),
+	certainty: z.enum(["clear", "uncertain"]),
+	clarifications: z.array(z.object({
+		at: z.number(),
+		text: z.string()
+	})),
+	decision: z.enum(PROPOSAL_DECISIONS),
+	evidenceIds: z.array(z.string()),
+	feedbackId: z.string().nullable(),
+	formulation: z.enum(["ai", "human"]),
+	handedOffRevision: z.number().nullable(),
+	id: z.string(),
+	intentionSuggestion: intentionSuggestionSchema.nullable(),
+	lastHandoff: lastHandoffSchema.nullable(),
+	mergedIntoId: z.string().nullable(),
+	mergeSuggestion: z.object({
+		reason: z.string(),
+		withIds: z.array(z.string())
+	}).nullable(),
+	need: z.string(),
+	needsReview: z.boolean(),
+	observed: z.string(),
+	origin: z.enum(["ai", "human"]),
+	question: z.string().nullable(),
+	refinement: z.object({
+		error: z.string().nullable(),
+		state: z.enum([
+			"running",
+			"failed",
+			"outdated"
+		])
+	}).nullable(),
+	response: z.string().nullable(),
+	revision: z.number(),
+	segmentIds: z.array(z.string()),
+	setAside: z.array(z.string()),
+	unknowns: z.array(z.string()),
+	updatedAt: z.number(),
+	verification: z.object({
+		at: z.number(),
+		note: z.string().nullable(),
+		sessionId: z.string().nullable(),
+		status: z.enum(["works", "needs_work"])
+	}).nullable()
+});
+const sessionHandoffSchema = z.object({
+	brief: z.string(),
+	createdAt: z.number(),
+	deliveries: z.array(z.object({
+		at: z.number(),
+		kind: z.enum(["copied", "exported"])
+	})),
+	evidenceIds: z.array(z.string()),
+	id: z.string(),
+	proposals: z.array(z.object({
+		id: z.string(),
+		need: z.string(),
+		revision: z.number()
+	}))
+});
+const sessionMarkSchema = z.object({
+	atMs: z.number(),
+	kind: z.enum([
+		"mark",
+		"select",
+		"navigation"
+	]),
+	label: z.string(),
+	note: z.string().nullable(),
+	url: z.string().nullable()
+});
+const sessionDetailSchema = z.object({
+	continuation: sessionContinuationSchema.nullable(),
+	contributedEvidence: z.array(sessionEvidenceSchema),
+	evidence: z.array(sessionEvidenceSchema),
+	handoffs: z.array(sessionHandoffSchema),
+	history: z.array(intentionHistoryEntrySchema),
+	marks: z.array(sessionMarkSchema),
+	proposals: z.array(sessionProposalSchema),
+	segments: z.array(sessionSegmentSchema),
+	session: sessionSummarySchema.extend({
+		canEdit: z.boolean(),
+		gaps: z.array(sessionGapSchema),
+		startUrl: z.string().nullable()
+	})
+});
+const handoffFileSchema = z.object({
+	evidenceId: z.string(),
+	name: z.string(),
+	url: z.string()
+});
+const sessionApiErrorSchema = z.object({
+	error: z.string(),
+	limit: z.enum(SESSION_LIMIT_KINDS).optional()
+});
+//#endregion
 //#region src/sessions/api/proposal-endpoints.ts
 const proposalResponse = z.object({ proposal: sessionProposalSchema });
-function createProposalEndpoints({ post }) {
-	const postProposal = async (path, body) => (await post(path, body, proposalResponse)).proposal;
+const intentionUpdateResponse = z.object({
+	contribution: sessionContributionSchema,
+	intention: continuedIntentionSchema.nullable()
+});
+const proposalPoster = ({ post }) => async (path, body) => (await post(path, body, proposalResponse)).proposal;
+function createProposalEndpoints(requests) {
+	const { post } = requests;
+	const postProposal = proposalPoster(requests);
 	return {
 		clarifyProposal: (body) => postProposal("/api/v1/sessions/proposals/clarify", body),
 		createFeedback: (proposalId) => post("/api/v1/sessions/proposals/feedback", { proposalId }, z.object({
@@ -105,6 +627,22 @@ function createProposalEndpoints({ post }) {
 		verifyProposal: (body) => postProposal("/api/v1/sessions/proposals/verify", body)
 	};
 }
+function createIntentionEndpoints(requests) {
+	const { post } = requests;
+	const postProposal = proposalPoster(requests);
+	const postIntentionUpdate = (path, body) => post(path, body, intentionUpdateResponse);
+	return {
+		acceptIntentionChanges: (body) => postIntentionUpdate("/api/v1/sessions/intentions/accept", body),
+		answerIntentionQuestion: (body) => postIntentionUpdate("/api/v1/sessions/intentions/answer", body),
+		attachToIntention: (body) => postProposal("/api/v1/sessions/intentions/attach", body),
+		deleteProposal: async (proposalId) => {
+			await post("/api/v1/sessions/proposals/delete", { proposalId }, z.object({ deleted: z.literal(true) }));
+		},
+		detachContribution: (contributionId) => postIntentionUpdate("/api/v1/sessions/intentions/detach", { contributionId }),
+		keepSeparate: (proposalId) => postProposal("/api/v1/sessions/intentions/keep-separate", { proposalId }),
+		reopenOrRejectChange: (body) => postIntentionUpdate("/api/v1/sessions/intentions/change", body)
+	};
+}
 //#endregion
 //#region src/sessions/api/recording-endpoints.ts
 const summaryResponse = z.object({ session: sessionSummarySchema });
@@ -127,9 +665,7 @@ function createRecordingEndpoints({ post }) {
 //#region src/sessions/api/review-endpoints.ts
 function createReviewEndpoints({ get, post }) {
 	return {
-		addTypedSegment: async (body) => (await post("/api/v1/sessions/segments", body, segmentResponse)).segment,
 		analyze: async (sessionId) => (await post("/api/v1/sessions/analyze", { sessionId }, z.object({ analysis: analysisStatusSchema }))).analysis,
-		correctSegment: async (body) => (await post("/api/v1/sessions/segments/correct", body, segmentResponse)).segment,
 		deleteSession: async (sessionId) => {
 			await post("/api/v1/sessions/delete", { sessionId }, z.object({ deleted: z.literal(true) }));
 		},
@@ -137,10 +673,19 @@ function createReviewEndpoints({ get, post }) {
 		identity: () => get("/api/v1/sessions/identity", sessionIdentitySchema),
 		list: async () => (await get("/api/v1/sessions/list", z.object({ sessions: z.array(sessionSummarySchema) }))).sessions,
 		removeEvidence: async (evidenceId) => (await post("/api/v1/sessions/evidence/remove", { evidenceId }, z.object({ evidence: sessionEvidenceSchema }))).evidence,
-		retrySegment: async (segmentId) => (await post("/api/v1/sessions/segments/retry", { segmentId }, segmentResponse)).segment,
 		update: async (body) => (await post("/api/v1/sessions/update", body, summaryResponse)).session
 	};
 }
+function createSegmentEndpoints({ get, post }) {
+	const postSegment = async (path, body) => (await post(path, body, segmentResponse)).segment;
+	return {
+		addTypedSegment: (body) => postSegment("/api/v1/sessions/segments", body),
+		contextChoices: async (segmentId) => (await get("/api/v1/sessions/segments/context-choices", z.object({ options: z.array(contextOptionSchema) }), { segmentId })).options,
+		correctSegment: (body) => postSegment("/api/v1/sessions/segments/correct", body),
+		retrySegment: (segmentId) => postSegment("/api/v1/sessions/segments/retry", { segmentId }),
+		setSegmentContext: (body) => postSegment("/api/v1/sessions/segments/context", body)
+	};
+}
 //#endregion
 //#region src/sessions/api/session-requests.ts
 function createSessionRequests(transport) {
@@ -176,7 +721,9 @@ function createSessionApi(transport) {
 	return {
 		...createRecordingEndpoints(requests),
 		...createReviewEndpoints(requests),
-		...createProposalEndpoints(requests)
+		...createSegmentEndpoints(requests),
+		...createProposalEndpoints(requests),
+		...createIntentionEndpoints(requests)
 	};
 }
 //#endregion
@@ -1493,7 +2040,7 @@ function captureFrame() {
 }
 //#endregion
 //#region src/sessions/capture/page/interaction-recorder.ts
-const DWELL_MS = 700;
+const MIN_DWELL_MS = 700;
 const POINTER_SAMPLE_INTERVAL_MS = 100;
 const SETTLE_DEBOUNCE_MS = 400;
 function eventElement(event) {
@@ -1504,14 +2051,14 @@ function eventElement(event) {
 	return element === document.body || element === document.documentElement ? null : element;
 }
 function pointerOf(event) {
-	return event instanceof MouseEvent ? {
+	return {
 		x: Math.round(event.clientX),
 		y: Math.round(event.clientY)
-	} : {
-		x: 0,
-		y: 0
 	};
 }
+function isPhysicalPointerClick(event) {
+	return event instanceof MouseEvent && event.detail > 0;
+}
 function debounced(signal, run) {
 	let settleTimer;
 	signal.addEventListener("abort", () => window.clearTimeout(settleTimer));
@@ -1528,34 +2075,50 @@ function recordClick(options) {
 			element: describeElementRef(element, options),
 			frame: captureFrame(),
 			kind: "click",
-			pointer: pointerOf(event)
+			pointer: isPhysicalPointerClick(event) ? pointerOf(event) : null
 		});
 	};
 }
 function watchDwell(options, signal) {
 	let hovered = null;
 	let lastSampleAt = Number.NEGATIVE_INFINITY;
-	let dwellTimer;
-	signal.addEventListener("abort", () => window.clearTimeout(dwellTimer));
-	return (event) => {
+	let entered = null;
+	const settle = () => {
+		if (!entered) return;
+		const durationMs = options.atMs() - entered.atMs;
+		if (durationMs >= MIN_DWELL_MS) options.onEvent({
+			...entered,
+			durationMs
+		});
+		entered = null;
+	};
+	signal.addEventListener("abort", settle);
+	const onPointerMove = (event) => {
+		if (!(event instanceof MouseEvent)) return;
 		const now = Date.now();
 		if (now - lastSampleAt < POINTER_SAMPLE_INTERVAL_MS) return;
 		lastSampleAt = now;
 		const element = eventElement(event);
 		if (element === hovered) return;
+		settle();
 		hovered = element;
-		window.clearTimeout(dwellTimer);
-		if (!element) return;
-		const atMs = options.atMs();
-		const pointer = pointerOf(event);
-		dwellTimer = window.setTimeout(() => options.onEvent({
-			atMs,
-			durationMs: DWELL_MS,
+		if (element) entered = {
+			atMs: options.atMs(),
 			element: describeElementRef(element, options),
 			frame: captureFrame(),
 			kind: "dwell",
-			pointer
-		}), DWELL_MS);
+			pointer: pointerOf(event)
+		};
+	};
+	const onPointerLeaveWindow = (event) => {
+		if (event instanceof MouseEvent && event.relatedTarget === null) {
+			settle();
+			hovered = null;
+		}
+	};
+	return {
+		onPointerLeaveWindow,
+		onPointerMove
 	};
 }
 function startInteractionRecorder(options) {
@@ -1579,8 +2142,10 @@ function startInteractionRecorder(options) {
 		viewportHeight: window.innerHeight,
 		viewportWidth: window.innerWidth
 	}));
+	const dwell = watchDwell(options, signal);
 	document.addEventListener("click", recordClick(options), listen);
-	document.addEventListener("pointermove", watchDwell(options, signal), listen);
+	document.addEventListener("pointermove", dwell.onPointerMove, listen);
+	document.addEventListener("pointerout", dwell.onPointerLeaveWindow, listen);
 	window.addEventListener("scroll", recordScroll, listen);
 	window.addEventListener("resize", recordViewport, listen);
 	return { stop: () => controller.abort() };
@@ -1713,25 +2278,26 @@ function blankFieldValues(root) {
 const NAVIGATION_SETTLE_MS = 1500;
 const CAPTURE_FAILED = "The page could not be captured.";
 const CAPTURE_TOO_LARGE = "The screenshot was larger than the upload limit.";
-async function shoot(base, maxImageBytes) {
+const STOPPED_BEFORE_CAPTURE = "Recording stopped before the screenshot was taken.";
+const withoutImage = (base, missingReason) => ({
+	...base,
+	capturedAtMs: null,
+	image: null,
+	missingReason
+});
+async function shoot(base, options) {
 	const image = await captureViewport({
 		excludeSelectors: SESSION_MASK_SELECTORS,
 		prepareClone: blankFieldValues
 	});
 	releaseCapture(image);
-	if (!image) return {
-		...base,
-		image: null,
-		missingReason: CAPTURE_FAILED
-	};
-	if (image.blob.size > maxImageBytes) return {
-		...base,
-		image: null,
-		missingReason: CAPTURE_TOO_LARGE
-	};
+	if (!image) return withoutImage(base, CAPTURE_FAILED);
+	if (image.blob.size > options.limits.maxImageBytes) return withoutImage(base, CAPTURE_TOO_LARGE);
 	const { blob, height, width } = image;
 	return {
 		...base,
+		capturedAtMs: options.atMs(),
+		frame: captureFrame(),
 		image: {
 			blob,
 			height,
@@ -1740,31 +2306,43 @@ async function shoot(base, maxImageBytes) {
 		missingReason: null
 	};
 }
+function evidenceBase(trigger, request, options) {
+	return {
+		atMs: options.atMs(),
+		clientKey: crypto.randomUUID(),
+		element: request.element ? describeElementRef(request.element, options) : null,
+		frame: captureFrame(),
+		note: request.note ?? null,
+		trigger
+	};
+}
 function createEvidenceScheduler(options) {
 	const { limits } = options;
 	let captured = 0;
 	let lastCaptureAtMs = Number.NEGATIVE_INFINITY;
 	let navigationTimer;
 	let previousCapture = Promise.resolve();
+	let collectionRun = 0;
 	const take = (trigger, request) => {
 		if (captured >= limits.maxEvidence) return null;
 		captured += 1;
-		const atMs = options.atMs();
-		lastCaptureAtMs = atMs;
-		const clientKey = crypto.randomUUID();
-		const base = {
-			atMs,
-			clientKey,
-			element: request.element ? describeElementRef(request.element, options) : null,
-			frame: captureFrame(),
-			note: request.note ?? null,
-			trigger
+		const base = evidenceBase(trigger, request, options);
+		lastCaptureAtMs = base.atMs;
+		const takenInRun = collectionRun;
+		const isCurrent = () => takenInRun === collectionRun;
+		const stopped = withoutImage(base, STOPPED_BEFORE_CAPTURE);
+		const captureUnlessStopped = async () => {
+			const evidence = isCurrent() ? await shoot(base, options) : stopped;
+			return isCurrent() ? evidence : stopped;
 		};
-		previousCapture = previousCapture.then(() => shoot(base, limits.maxImageBytes)).then(options.onEvidence);
-		return clientKey;
+		previousCapture = previousCapture.then(captureUnlessStopped).then(options.onEvidence);
+		return base.clientKey;
 	};
 	return {
-		cancelPending: () => window.clearTimeout(navigationTimer),
+		cancelPending: () => {
+			window.clearTimeout(navigationTimer);
+			collectionRun += 1;
+		},
 		capture: (request) => take(request.trigger, request),
 		navigated: () => {
 			window.clearTimeout(navigationTimer);
@@ -1866,7 +2444,8 @@ function startPayload(draft) {
 			},
 			startedAt: draft.startedAt,
 			surface: draft.surface,
-			...draft.title ? { title: draft.title } : {}
+			...draft.title ? { title: draft.title } : {},
+			...draft.continues ? { continues: draft.continues } : {}
 		},
 		kind: "start"
 	};
@@ -1876,6 +2455,7 @@ function evidencePayload(captured) {
 	return {
 		evidence: {
 			atMs: captured.atMs,
+			capturedAtMs: captured.capturedAtMs ?? void 0,
 			clientKey: captured.clientKey,
 			element: element ?? void 0,
 			frame: captured.frame,
@@ -2252,6 +2832,7 @@ var RecordingController = class {
 		if (!voice) return;
 		const draft = newSessionDraft({
 			accountKey: this.options.account.key,
+			continues: options.continues,
 			surface: this.options.surface,
 			title: cleanText(options.title, MAX_TITLE_CHARS) ?? ""
 		});
@@ -2603,6 +3184,9 @@ function shortDuration(ms) {
 	if (minutes === 0) return `${seconds} s`;
 	return seconds === 0 ? `${minutes} min` : `${minutes} min ${seconds} s`;
 }
+function preciseSeconds(ms) {
+	return `${(Math.abs(ms) / SECOND_MS).toFixed(1)} s`;
+}
 function minutesLeft(remainingMs) {
 	return Math.max(1, Math.ceil(remainingMs / MINUTE_MS));
 }
@@ -2626,12 +3210,13 @@ function sessionStatusLine(summary) {
 	if (isAnalysisBusy(summary)) return "Reading";
 	if (analysis.state === "failed") return "Analysis failed";
 	if (analysis.state === "idle") return "Not analyzed yet";
-	return `${countLabel(counts.proposals, "proposal")} · ${counts.kept} kept`;
+	return `${countLabel(counts.proposals, "intention")} · ${counts.kept} confirmed`;
 }
 function isDetailProcessing(detail) {
 	const transcribing = detail.segments.some((segment) => segment.transcription.state === "pending" || segment.transcription.state === "running");
 	const refining = detail.proposals.some((proposal) => proposal.refinement?.state === "running");
-	return transcribing || refining || isAnalysisBusy(detail.session) || detail.session.collection !== "ended";
+	const comparing = detail.continuation?.contribution.state === "analyzing";
+	return transcribing || refining || comparing || isAnalysisBusy(detail.session) || detail.session.collection !== "ended";
 }
 //#endregion
 //#region src/sessions/ui/session-icons.tsx
@@ -2917,6 +3502,34 @@ function RecordingLayer({ onFinished }) {
 	})] });
 }
 //#endregion
+//#region src/sessions/ui/intention-styles.ts
+const INTENTION_STYLES = `
+.dt-ses-panel { display: contents; }
+.dt-ses-panel[hidden] { display: none; }
+.dt-ses-moment, .dt-ses-moment-section, .dt-ses-block, .dt-ses-change, .dt-ses-history { display: flex; flex-direction: column; gap: 6px; min-width: 0; }
+.dt-ses-moment-item { display: flex; flex-direction: column; gap: 6px; padding: 8px 10px; border-radius: 10px; background: var(--rf-bg-subtle); }
+.dt-ses-moment-line { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin: 0; overflow-wrap: anywhere; }
+.dt-ses-moment-quote { display: flex; flex-direction: column; gap: 2px; margin: 0; padding-left: 10px; border-left: 2px solid var(--rf-border); overflow-wrap: anywhere; }
+.dt-ses-moment-notices { color: var(--rf-text-muted); font-size: 12px; }
+.dt-ses-moment-shot { display: flex; flex-direction: column; gap: 4px; margin: 0; max-width: 100%; }
+.dt-ses-shot-mark[data-match="approximate"] { border-style: dashed; }
+.dt-ses-shot-pointer {
+  position: absolute; width: 10px; height: 10px; margin: -5px 0 0 -5px; border-radius: 50%;
+  background: var(--rf-accent); box-shadow: 0 0 0 2px var(--rf-bg); pointer-events: none;
+}
+.dt-ses-source { margin: 0; font-size: 12px; overflow-wrap: anywhere; }
+.dt-ses-context-line { display: block; }
+.dt-ses-attached { flex-direction: row; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 6px; }
+.dt-ses-attached p { margin: 0; }
+.dt-ses-history[data-removed="true"] > .dt-ses-subhead { color: var(--rf-text-muted); text-decoration: line-through; }
+.dt-ses-change { padding: 8px 10px; border-radius: 10px; background: var(--rf-bg-subtle); list-style: none; }
+.dt-ses-change[data-decision="rejected"] .dt-ses-diff { color: var(--rf-text-muted); text-decoration: line-through; }
+.dt-ses-diff { display: grid; grid-template-columns: auto 1fr; gap: 2px 8px; margin: 0; overflow-wrap: anywhere; }
+p.dt-ses-diff { display: block; }
+.dt-ses-diff dd { margin: 0; }
+.dt-card:focus-visible { outline: 2px solid var(--rf-accent); outline-offset: 2px; }
+`;
+//#endregion
 //#region src/sessions/ui/sessions-styles.ts
 const MONO_FONT$1 = "ui-monospace, SFMono-Regular, Menlo, Consolas, monospace";
 const SESSIONS_STYLES = `${`
@@ -3011,7 +3624,7 @@ ${`
 .dt-team-anchor[data-edge="top"] { top: calc(var(--rf-viewport-top, 0px) + env(safe-area-inset-top) + var(--dt-edge-gap)); }
 .dt-team-card { display: flex; flex-direction: column; gap: 6px; padding: 12px 14px; border-radius: 14px; animation: dt-popover-in 200ms var(--rf-ease); }
 .dt-bar > .dt-btn { margin-inline: 2px 4px; }
-`}`;
+`}${INTENTION_STYLES}`;
 //#endregion
 //#region src/devtools/client/clipboard.ts
 /**
@@ -3661,21 +4274,28 @@ function evidenceCaption(evidence) {
 	const element = evidence.element ? ` · ${evidence.element.label}` : "";
 	return `${TRIGGER_LABELS[evidence.trigger]}${element}`;
 }
-function highlightStyle(evidence) {
-	const { element, frame } = evidence;
-	if (!(element && frame) || frame.viewportWidth === 0 || frame.viewportHeight === 0) return null;
-	const percent = (value, total) => `${value / total * 100}%`;
+const hasViewport = (frame) => frame.viewportWidth > 0 && frame.viewportHeight > 0;
+const percent = (value, total) => `${value / total * 100}%`;
+function percentBox(rect, frame) {
+	if (!hasViewport(frame)) return null;
+	return {
+		height: percent(rect.height, frame.viewportHeight),
+		left: percent(rect.x, frame.viewportWidth),
+		top: percent(rect.y, frame.viewportHeight),
+		width: percent(rect.width, frame.viewportWidth)
+	};
+}
+function percentPoint(point, frame) {
+	if (!hasViewport(frame)) return null;
 	return {
-		height: percent(element.rect.height, frame.viewportHeight),
-		left: percent(element.rect.x, frame.viewportWidth),
-		top: percent(element.rect.y, frame.viewportHeight),
-		width: percent(element.rect.width, frame.viewportWidth)
+		left: percent(point.x, frame.viewportWidth),
+		top: percent(point.y, frame.viewportHeight)
 	};
 }
 function EvidenceThumb({ evidence, isLarge = false }) {
-	const { image } = evidence;
+	const { element, frame, image } = evidence;
 	if (!image?.url) return null;
-	const highlight = highlightStyle(evidence);
+	const highlight = element && frame ? percentBox(element.rect, frame) : null;
 	return /* @__PURE__ */ jsxs("span", {
 		className: "dt-ses-shot",
 		"data-large": isLarge,
@@ -3692,13 +4312,246 @@ function EvidenceThumb({ evidence, isLarge = false }) {
 	});
 }
 //#endregion
+//#region src/sessions/ui/review/continuation/intention-history.tsx
+const FIELD_LABELS = {
+	need: "Need",
+	observed: "Observed",
+	response: "Considered response",
+	setAside: "Set aside",
+	unknowns: "To check"
+};
+function fieldValueText(value) {
+	return (Array.isArray(value) ? value.join("; ") : value) || "—";
+}
+function AppliedChanges({ applied }) {
+	if (applied.length === 0) return null;
+	return /* @__PURE__ */ jsx("ul", {
+		className: "dt-ses-rows",
+		children: applied.map((change) => /* @__PURE__ */ jsxs("li", {
+			className: "dt-ses-row",
+			children: [/* @__PURE__ */ jsxs("p", {
+				className: "dt-meta",
+				children: [
+					"Accepted into revision ",
+					change.revision,
+					" by",
+					" ",
+					change.byName ?? "a teammate",
+					" · ",
+					formatDate(change.at)
+				]
+			}), /* @__PURE__ */ jsx("ul", {
+				className: "dt-ses-list",
+				children: change.fields.map((field) => /* @__PURE__ */ jsxs("li", { children: [
+					FIELD_LABELS[field.field],
+					": ",
+					fieldValueText(field.before),
+					" →",
+					" ",
+					fieldValueText(field.after)
+				] }, field.field))
+			})]
+		}, change.revision))
+	});
+}
+function HistoryExtracts({ evidence, quotes }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [quotes.map((quote) => /* @__PURE__ */ jsxs("blockquote", {
+		className: "dt-ses-moment-quote",
+		children: [
+			/* @__PURE__ */ jsx("span", {
+				className: "dt-ses-time",
+				children: formatClock(quote.startMs)
+			}),
+			` “${quote.text}”`,
+			quote.context.map((line) => /* @__PURE__ */ jsx("span", {
+				className: "dt-meta dt-ses-context-line",
+				children: line
+			}, line))
+		]
+	}, quote.segmentId)), evidence.length > 0 && /* @__PURE__ */ jsx("div", {
+		className: "dt-ses-thumbs",
+		children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
+	})] });
+}
+function entryTitle(entry) {
+	const { session } = entry;
+	return entry.origin === "continuation" ? `Continued in “${session.title}” · ${formatDate(session.startedAt)}` : `Added from “${session.title}” · ${formatDate(session.startedAt)}`;
+}
+function HistoryEntry({ context, entry }) {
+	const evidenceIds = new Set(entry.evidenceIds);
+	const evidence = context.detail.contributedEvidence.filter((item) => evidenceIds.has(item.id));
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-history",
+		"data-removed": entry.detachedAt !== null,
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-ses-subhead",
+				children: entryTitle(entry)
+			}),
+			entry.detachedAt !== null && /* @__PURE__ */ jsxs("p", {
+				className: "dt-meta",
+				children: [
+					"Removed on ",
+					formatDate(entry.detachedAt),
+					": what it added was taken back."
+				]
+			}),
+			/* @__PURE__ */ jsx(AppliedChanges, { applied: entry.applied }),
+			entry.extractsHidden ? /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: "Extracts are private to the author"
+			}) : /* @__PURE__ */ jsx(HistoryExtracts, {
+				evidence,
+				quotes: entry.quotes
+			}),
+			entry.session.canOpen && /* @__PURE__ */ jsx("button", {
+				className: "dt-ses-link",
+				onClick: () => context.navigation.onOpenSession(entry.session.id),
+				type: "button",
+				children: "Open session"
+			})
+		]
+	});
+}
+function IntentionHistory({ context, intentionId }) {
+	const entries = context.detail.history.filter((entry) => entry.intentionId === intentionId);
+	if (entries.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
+		className: "dt-ses-label",
+		children: "History"
+	}), /* @__PURE__ */ jsx("ul", {
+		className: "dt-ses-rows",
+		children: entries.map((entry) => /* @__PURE__ */ jsx(HistoryEntry, {
+			context,
+			entry
+		}, entry.id))
+	})] });
+}
+//#endregion
+//#region src/sessions/ui/handoff/handoff-changes.tsx
+function differences(proposal, last) {
+	return [
+		{
+			after: proposal.need,
+			before: last.need,
+			label: "Need"
+		},
+		{
+			after: fieldValueText(proposal.response),
+			before: fieldValueText(last.response),
+			label: "Considered response"
+		},
+		{
+			after: fieldValueText(proposal.unknowns),
+			before: last.unknowns === null ? null : fieldValueText(last.unknowns),
+			label: "To check"
+		}
+	].flatMap(({ after, before, label }) => before === null || before === after ? [] : [{
+		after,
+		before,
+		label
+	}]);
+}
+function ChangeSummary({ last, proposal }) {
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-row",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-ses-subhead",
+				children: proposal.need
+			}),
+			/* @__PURE__ */ jsxs("p", {
+				className: "dt-meta",
+				children: [
+					"Changed since the brief of ",
+					formatDate(last.at),
+					" (revision",
+					" ",
+					last.revision,
+					" → ",
+					proposal.revision,
+					")"
+				]
+			}),
+			/* @__PURE__ */ jsx("ul", {
+				className: "dt-ses-list",
+				children: differences(proposal, last).map((difference) => /* @__PURE__ */ jsxs("li", { children: [
+					difference.label,
+					": ",
+					difference.before,
+					" → ",
+					difference.after
+				] }, difference.label))
+			})
+		]
+	});
+}
+function ChangedSinceBriefs({ detail, proposalIds }) {
+	const selected = new Set(proposalIds);
+	const changed = detail.proposals.flatMap((proposal) => {
+		const last = proposal.lastHandoff;
+		return selected.has(proposal.id) && last && last.revision < proposal.revision ? [{
+			last,
+			proposal
+		}] : [];
+	});
+	if (changed.length === 0) return null;
+	return /* @__PURE__ */ jsx("ul", {
+		className: "dt-ses-rows",
+		children: changed.map(({ last, proposal }) => /* @__PURE__ */ jsx(ChangeSummary, {
+			last,
+			proposal
+		}, proposal.id))
+	});
+}
+function deliveryLine(handoff) {
+	const kinds = new Set(handoff.deliveries.map((delivery) => delivery.kind));
+	if (kinds.size === 0) return "not copied or exported";
+	return [...kinds].join(" and ");
+}
+function intentionsLine(handoff) {
+	const [only, ...others] = handoff.proposals;
+	if (only && others.length === 0) return `“${only.need}” revision ${only.revision}`;
+	return countLabel(handoff.proposals.length, "intention");
+}
+function PreviousBriefs({ handoffs }) {
+	if (handoffs.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-form",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "dt-ses-label",
+			children: "Previous briefs"
+		}), /* @__PURE__ */ jsx("ul", {
+			className: "dt-ses-rows",
+			children: handoffs.map((handoff) => {
+				const date = formatDate(handoff.createdAt);
+				return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("details", { children: [/* @__PURE__ */ jsxs("summary", { children: [
+					date,
+					" · ",
+					intentionsLine(handoff),
+					" · ",
+					deliveryLine(handoff)
+				] }), /* @__PURE__ */ jsx("textarea", {
+					"aria-label": `Brief of ${date}`,
+					className: "dt-field dt-ses-brief",
+					readOnly: true,
+					rows: 8,
+					value: handoff.brief
+				})] }) }, handoff.id);
+			})
+		})]
+	});
+}
+//#endregion
 //#region src/sessions/ui/handoff/handoff-selection.tsx
 function keptProposals(detail) {
 	return detail.proposals.filter((proposal) => proposal.decision === "kept" && proposal.mergedIntoId === null);
 }
 function evidenceOf(detail, proposals) {
-	const cited = new Set(proposals.flatMap((proposal) => proposal.evidenceIds));
-	return detail.evidence.filter((item) => cited.has(item.id) && item.status === "available");
+	const intentionIds = new Set(proposals.map((proposal) => proposal.id));
+	const contributed = detail.history.filter((entry) => intentionIds.has(entry.intentionId) && entry.detachedAt === null);
+	const cited = /* @__PURE__ */ new Set([...proposals.flatMap((proposal) => proposal.evidenceIds), ...contributed.flatMap((entry) => entry.evidenceIds)]);
+	return [...detail.evidence, ...detail.contributedEvidence].filter((item) => cited.has(item.id) && item.status === "available");
 }
 function initialSelection(detail) {
 	const proposals = keptProposals(detail);
@@ -3746,7 +4599,7 @@ function HandoffChoices({ detail, onChange, selection }) {
 	const chosenProposalIds = new Set(selection.proposalIds);
 	const chosenEvidenceIds = new Set(selection.evidenceIds);
 	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(ChoiceGroup, {
-		legend: "Proposals",
+		legend: "Intentions",
 		children: proposals.map((proposal) => /* @__PURE__ */ jsx(CheckRow, {
 			isChecked: chosenProposalIds.has(proposal.id),
 			label: proposal.need,
@@ -3883,6 +4736,10 @@ function SelectionStep({ detail, handoff }) {
 			onChange: handoff.select,
 			selection: handoff.selection
 		}),
+		/* @__PURE__ */ jsx(ChangedSinceBriefs, {
+			detail,
+			proposalIds: handoff.selection.proposalIds
+		}),
 		/* @__PURE__ */ jsxs("div", {
 			className: "dt-actions",
 			children: [/* @__PURE__ */ jsx("button", {
@@ -3933,196 +4790,60 @@ function HandoffView({ detail, onClose, review }) {
 			/* @__PURE__ */ jsx("p", {
 				className: "dt-meta",
 				children: "Copied or exported briefs can't be recalled."
-			})
+			}),
+			/* @__PURE__ */ jsx(PreviousBriefs, { handoffs: detail.handoffs })
 		]
 	});
 }
 //#endregion
-//#region src/sessions/ui/review/proposals/proposal-details.tsx
-function ListSection({ items, title }) {
-	if (items.length === 0) return null;
-	return /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
-		className: "dt-ses-label",
-		children: title
-	}), /* @__PURE__ */ jsx("ul", {
-		className: "dt-ses-list",
-		children: items.map((item) => /* @__PURE__ */ jsx("li", { children: item }, item))
-	})] });
+//#region src/sessions/ui/review/guarded-save.tsx
+function useGuardedSave() {
+	const { onUnauthorized } = useSessionWorkspace();
+	const [problem, setProblem] = useState(null);
+	const [isSaving, setIsSaving] = useState(false);
+	const save = async (write) => {
+		setIsSaving(true);
+		setProblem(null);
+		try {
+			await write();
+		} catch (error) {
+			if (isUnauthorized(error)) onUnauthorized();
+			else if (error instanceof SessionApiError && error.status === 409) setProblem({ kind: "stale" });
+			else setProblem({
+				kind: "failed",
+				message: failureMessage(error)
+			});
+		}
+		setIsSaving(false);
+	};
+	return {
+		isSaving,
+		problem,
+		save
+	};
 }
-function RefinementState({ onRetry, proposal }) {
-	const { refinement } = proposal;
-	if (refinement?.state === "running") return /* @__PURE__ */ jsx("p", {
-		className: "dt-status",
-		children: "Refining…"
-	});
-	if (refinement?.state === "outdated") return /* @__PURE__ */ jsx("p", {
-		className: "dt-meta",
-		children: "The proposal changed while it was being refined. Add your precision again."
-	});
-	if (refinement?.state !== "failed") return null;
+function SaveProblemMessage({ onReload, problem }) {
 	return /* @__PURE__ */ jsxs("div", {
 		className: "dt-actions",
-		children: [/* @__PURE__ */ jsxs("p", {
+		role: "alert",
+		children: [/* @__PURE__ */ jsx("p", {
 			className: "dt-error",
-			children: ["Refining failed: ", refinement.error ?? "Unknown error."]
-		}), /* @__PURE__ */ jsx("button", {
+			children: problem.kind === "stale" ? "Someone changed this since you opened it. Reload it, then edit again." : `Not saved: ${problem.message}`
+		}), problem.kind === "stale" && /* @__PURE__ */ jsx("button", {
 			className: "dt-btn",
-			onClick: onRetry,
+			onClick: onReload,
 			type: "button",
-			children: "Retry"
+			children: "Reload"
 		})]
 	});
 }
-function ClarifyBox({ context, proposal }) {
-	const [text, setText] = useState("");
-	const isRefining = proposal.refinement?.state === "running";
-	const lastClarification = proposal.clarifications.at(-1)?.text;
-	const send = async (value) => {
-		if (await context.actions.clarify(proposal, value)) setText("");
-	};
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-form",
-		children: [
-			proposal.question && /* @__PURE__ */ jsx("p", {
-				className: "dt-note-text",
-				children: proposal.question
-			}),
-			/* @__PURE__ */ jsx("textarea", {
-				"aria-label": proposal.question ? "Your answer" : "Add a precision…",
-				className: "dt-field",
-				disabled: isRefining,
-				maxLength: 1e3,
-				onChange: (event) => setText(event.target.value),
-				placeholder: "Add a precision…",
-				rows: 2,
-				value: text
-			}),
-			/* @__PURE__ */ jsx("div", {
-				className: "dt-actions",
-				children: /* @__PURE__ */ jsx("button", {
-					className: "dt-btn",
-					disabled: isRefining || text.trim() === "",
-					onClick: () => send(text.trim()),
-					type: "button",
-					children: "Update proposal"
-				})
-			}),
-			/* @__PURE__ */ jsx(RefinementState, {
-				onRetry: () => lastClarification && send(lastClarification),
-				proposal
-			})
-		]
-	});
-}
-function Sources({ context, proposal }) {
-	const segmentIds = new Set(proposal.segmentIds);
-	const evidenceIds = new Set(proposal.evidenceIds);
-	const segments = context.detail.segments.filter((segment) => segmentIds.has(segment.id));
-	const evidence = context.detail.evidence.filter((item) => evidenceIds.has(item.id));
-	if (segments.length + evidence.length === 0) return null;
-	return /* @__PURE__ */ jsxs("section", { children: [
-		/* @__PURE__ */ jsx("h4", {
-			className: "dt-ses-label",
-			children: "Sources"
-		}),
-		segments.map((segment) => /* @__PURE__ */ jsxs("button", {
-			className: "dt-ses-quote",
-			onClick: () => context.onShowSegment(segment.id),
-			type: "button",
-			children: [/* @__PURE__ */ jsx("span", {
-				className: "dt-ses-time",
-				children: formatClock(segment.startMs)
-			}), ` “${segment.text}”`]
-		}, segment.id)),
-		/* @__PURE__ */ jsx("div", {
-			className: "dt-ses-thumbs",
-			children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
-		})
-	] });
-}
-function ProposalDetails({ context, proposal }) {
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		/* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
-			className: "dt-ses-label",
-			children: "What you said or showed — not verified"
-		}), /* @__PURE__ */ jsx("p", {
-			className: "dt-note-text",
-			children: proposal.observed
-		})] }),
-		proposal.response && /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
-			className: "dt-ses-label",
-			children: "Considered response"
-		}), /* @__PURE__ */ jsx("p", {
-			className: "dt-note-text",
-			children: proposal.response
-		})] }),
-		/* @__PURE__ */ jsx(ListSection, {
-			items: proposal.setAside,
-			title: "Set aside"
-		}),
-		/* @__PURE__ */ jsx(ListSection, {
-			items: proposal.unknowns,
-			title: "Unknowns"
-		}),
-		context.canEdit && /* @__PURE__ */ jsx(ClarifyBox, {
-			context,
-			proposal
-		}),
-		/* @__PURE__ */ jsx(Sources, {
-			context,
-			proposal
-		})
-	] });
-}
-//#endregion
-//#region src/sessions/ui/review/guarded-save.tsx
-function useGuardedSave() {
-	const { onUnauthorized } = useSessionWorkspace();
-	const [problem, setProblem] = useState(null);
-	const [isSaving, setIsSaving] = useState(false);
-	const save = async (write) => {
-		setIsSaving(true);
-		setProblem(null);
-		try {
-			await write();
-		} catch (error) {
-			if (isUnauthorized(error)) onUnauthorized();
-			else if (error instanceof SessionApiError && error.status === 409) setProblem({ kind: "stale" });
-			else setProblem({
-				kind: "failed",
-				message: failureMessage(error)
-			});
-		}
-		setIsSaving(false);
-	};
-	return {
-		isSaving,
-		problem,
-		save
-	};
-}
-function SaveProblemMessage({ onReload, problem }) {
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-actions",
-		role: "alert",
-		children: [/* @__PURE__ */ jsx("p", {
-			className: "dt-error",
-			children: problem.kind === "stale" ? "Someone changed this since you opened it. Reload it, then edit again." : `Not saved: ${problem.message}`
-		}), problem.kind === "stale" && /* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			onClick: onReload,
-			type: "button",
-			children: "Reload"
-		})]
-	});
-}
-//#endregion
-//#region src/sessions/ui/review/use-session-detail.ts
-const POLL_INTERVAL_MS = 2e3;
-function nextRequest(current) {
-	return {
-		...current,
-		count: current.count + 1
+//#endregion
+//#region src/sessions/ui/review/use-session-detail.ts
+const POLL_INTERVAL_MS = 2e3;
+function nextRequest(current) {
+	return {
+		...current,
+		count: current.count + 1
 	};
 }
 function withProposal(detail, proposal) {
@@ -4342,147 +5063,2295 @@ function ProposalEditor({ onDone, proposal, review }) {
 		]
 	});
 }
-//#endregion
-//#region src/sessions/ui/review/proposals/use-proposal-actions.ts
-const NOTICE_NEED_LENGTH = 60;
-const DECISION_NOTICE = {
-	dismissed: "Dismissed",
-	kept: "Kept",
-	later: "Saved for later",
-	pending: "Back to undecided"
-};
-function quotedNeed(need) {
-	return `“${need.length > NOTICE_NEED_LENGTH ? `${need.slice(0, 59)}…` : need}”`;
-}
-function useProposalSave(review) {
+function ResponseEditor({ onDone, proposal, review }) {
 	const { api } = useSessionWorkspace();
-	const run = useSessionAction();
-	return async (failureLabel, request) => {
-		const proposal = await run(failureLabel, () => request(api));
-		if (proposal) review.patch((detail) => withProposal(detail, proposal));
-		return proposal;
-	};
-}
-function decideWithUndo(save) {
-	const restore = async (proposalId, decision) => {
-		if (await save("The decision was not undone", (client) => client.decideProposal({
-			decision,
-			proposalId
-		}))) announce("Decision undone");
-	};
-	return async (proposal, decision) => {
-		const previous = proposal.decision;
-		if (await save("The decision was not saved", (client) => client.decideProposal({
-			decision,
-			proposalId: proposal.id
-		}))) announce(`${DECISION_NOTICE[decision]} ${quotedNeed(proposal.need)}`, {
-			label: "Undo",
-			run: () => restore(proposal.id, previous)
-		});
-	};
-}
-function useProposalActions(review) {
-	const save = useProposalSave(review);
-	return {
-		clarify: (proposal, text) => save("The precision was not sent", (client) => client.clarifyProposal({
+	const { isSaving, problem, save } = useGuardedSave();
+	const [response, setResponse] = useState(proposal.response ?? "");
+	const submit = () => save(async () => {
+		const saved = await api.editProposal({
 			expectedRevision: proposal.revision,
 			proposalId: proposal.id,
-			text
-		})),
-		decide: decideWithUndo(save),
-		merge: async (targetId, sourceIds) => {
-			if (await save("The proposals were not merged", (client) => client.mergeProposals({
-				sourceIds,
-				targetId
-			}))) review.reload();
+			response: response.trim() || null
+		});
+		review.patch((detail) => withProposal(detail, saved));
+		onDone();
+	});
+	return /* @__PURE__ */ jsxs("form", {
+		className: "dt-ses-form",
+		onSubmit: (event) => {
+			event.preventDefault();
+			submit();
 		},
-		save,
-		separate: (proposalId) => save("The suggestion was not cleared", (client) => client.separateProposal(proposalId)),
-		verify: (proposalId, { note, status }) => save("The check was not saved", (client) => client.verifyProposal({
-			note: note || void 0,
-			proposalId,
-			status
-		}))
-	};
-}
-//#endregion
-//#region src/sessions/ui/review/proposals/verification.tsx
-const OUTCOME_LABELS = {
-	needs_work: "Needs more work",
-	works: "Works"
-};
-function Verification({ context, proposal }) {
-	const [note, setNote] = useState(proposal.verification?.note ?? "");
-	if (proposal.handedOffRevision === null) return null;
-	const { verification } = proposal;
-	return /* @__PURE__ */ jsxs("fieldset", {
-		className: "dt-ses-verify",
 		children: [
-			/* @__PURE__ */ jsx("legend", {
-				className: "dt-ses-label",
-				children: "Did the change work?"
-			}),
-			verification && /* @__PURE__ */ jsxs("p", {
-				className: "dt-meta",
-				children: [
-					"Checked: ",
-					OUTCOME_LABELS[verification.status],
-					verification.note ? ` · ${verification.note}` : ""
-				]
-			}),
-			/* @__PURE__ */ jsx("input", {
-				"aria-label": "Note about the change (optional)",
-				className: "dt-field",
+			/* @__PURE__ */ jsx(TextField, {
+				label: "Considered response",
 				maxLength: 1e3,
-				onChange: (event) => setNote(event.target.value),
-				placeholder: "Note (optional)",
-				value: note
+				onChange: setResponse,
+				rows: 3,
+				value: response
 			}),
-			/* @__PURE__ */ jsx("div", {
-				className: "dt-actions",
-				children: ["works", "needs_work"].map((status) => /* @__PURE__ */ jsx("button", {
-					"aria-pressed": verification?.status === status,
-					className: "dt-btn",
-					onClick: () => context.actions.verify(proposal.id, {
-						note: note.trim(),
-						status
-					}),
-					type: "button",
-					children: OUTCOME_LABELS[status]
-				}, status))
+			problem && /* @__PURE__ */ jsx(SaveProblemMessage, {
+				onReload: review.reload,
+				problem
+			}),
+			/* @__PURE__ */ jsx(FormActions, {
+				isSubmitDisabled: isSaving,
+				onCancel: onDone,
+				submitLabel: "Save response"
 			})
 		]
 	});
 }
 //#endregion
-//#region src/sessions/ui/review/proposals/proposal-card.tsx
-const DECISION_CHIPS = {
-	dismissed: "Dismissed",
-	kept: "Kept",
-	later: "Later"
-};
-const DECISION_BUTTONS = [
-	{
-		decision: "kept",
-		label: "Keep"
-	},
-	{
-		decision: "later",
-		label: "Later"
-	},
-	{
-		decision: "dismissed",
-		label: "Dismiss"
-	}
-];
-function ProposalChips({ proposal }) {
-	const decisionChip = DECISION_CHIPS[proposal.decision];
-	const { handedOffRevision } = proposal;
-	let handoffChip = null;
-	if (handedOffRevision !== null) handoffChip = proposal.revision > handedOffRevision ? "Changed since handoff" : `Handed off rev ${handedOffRevision}`;
+//#region src/sessions/ui/review/continuation/share-preview.tsx
+function ExtractList({ detail, extracts }) {
+	const segmentIds = new Set(extracts.segmentIds);
+	const evidenceIds = new Set(extracts.evidenceIds);
+	const quotes = detail.segments.filter((segment) => segmentIds.has(segment.id));
+	const screenshots = detail.evidence.filter((item) => evidenceIds.has(item.id) && item.status === "available");
+	if (quotes.length + screenshots.length === 0) return /* @__PURE__ */ jsx("p", { children: "No quote or screenshot from this private session becomes visible to your team." });
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("p", { children: "These extracts from this private session become visible to your team:" }),
+		/* @__PURE__ */ jsx("ul", {
+			className: "dt-ses-list",
+			children: quotes.map((segment) => /* @__PURE__ */ jsxs("li", { children: [/* @__PURE__ */ jsx("span", {
+				className: "dt-ses-time",
+				children: formatClock(segment.startMs)
+			}), ` “${segment.text}”`] }, segment.id))
+		}),
+		/* @__PURE__ */ jsx("div", {
+			className: "dt-ses-thumbs",
+			children: screenshots.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
+		})
+	] });
+}
+function SharePreview({ confirmation, detail, extracts }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsx(ExtractList, {
+			detail,
+			extracts
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				"data-variant": "primary",
+				disabled: confirmation.isBusy,
+				onClick: confirmation.onConfirm,
+				type: "button",
+				children: confirmation.label
+			}), /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: confirmation.onCancel,
+				type: "button",
+				children: "Cancel"
+			})]
+		})]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/continuation/intention-change.tsx
+const KIND_LABELS$1 = {
+	constraint: "New constraint",
+	contradiction: "Contradiction",
+	outcome: "Observed result",
+	precision: "Precision",
+	solution: "Different solution"
+};
+function ChangeValue({ change, intention }) {
+	if (change.operation === "add") return /* @__PURE__ */ jsxs("p", {
+		className: "dt-ses-diff",
+		children: ["+ ", change.value]
+	});
+	if (change.operation === "remove") return /* @__PURE__ */ jsxs("p", {
+		className: "dt-ses-diff",
+		children: ["− ", change.value]
+	});
+	return /* @__PURE__ */ jsxs("dl", {
+		className: "dt-ses-diff",
+		children: [
+			/* @__PURE__ */ jsx("dt", {
+				className: "dt-ses-label",
+				children: "Current"
+			}),
+			/* @__PURE__ */ jsx("dd", { children: fieldValueText(intention[change.field]) }),
+			/* @__PURE__ */ jsx("dt", {
+				className: "dt-ses-label",
+				children: "Proposed"
+			}),
+			/* @__PURE__ */ jsx("dd", { children: change.value })
+		]
+	});
+}
+function ChangeSources({ change, context }) {
+	const segmentIds = new Set(change.segmentIds);
+	const evidenceIds = new Set(change.evidenceIds);
+	const segments = context.detail.segments.filter((segment) => segmentIds.has(segment.id));
+	const evidence = context.detail.evidence.filter((item) => evidenceIds.has(item.id));
+	return /* @__PURE__ */ jsxs(Fragment, { children: [segments.map((segment) => /* @__PURE__ */ jsxs("button", {
+		className: "dt-ses-quote",
+		onClick: (event) => context.navigation.onShowMoment(segment.id, event.currentTarget),
+		type: "button",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "dt-ses-time",
+			children: formatClock(segment.startMs)
+		}), ` “${segment.text}”`]
+	}, segment.id)), evidence.length > 0 && /* @__PURE__ */ jsx("div", {
+		className: "dt-ses-thumbs",
+		children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
+	})] });
+}
+function EditedValueForm({ handlers, initialValue, isSaving, label }) {
+	const [value, setValue] = useState(initialValue);
+	return /* @__PURE__ */ jsxs("form", {
+		className: "dt-ses-form",
+		onSubmit: (event) => {
+			event.preventDefault();
+			handlers.onAccept(value.trim());
+		},
+		children: [/* @__PURE__ */ jsx(TextField, {
+			label,
+			maxLength: 2e3,
+			onChange: setValue,
+			rows: 3,
+			value
+		}), /* @__PURE__ */ jsx(FormActions, {
+			isSubmitDisabled: isSaving || value.trim() === "",
+			onCancel: handlers.onCancel,
+			submitLabel: "Accept edited"
+		})]
+	});
+}
+function PendingChoices({ handlers, isSaving }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				"data-variant": "primary",
+				disabled: isSaving,
+				onClick: handlers.onAccept,
+				type: "button",
+				children: "Accept"
+			}),
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: handlers.onEdit,
+				type: "button",
+				children: "Edit then accept"
+			}),
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: handlers.onReject,
+				type: "button",
+				children: "Reject"
+			})
+		]
+	});
+}
+function useChangeAcceptance(change, scope) {
+	const [mode, setMode] = useState({ kind: "idle" });
+	const { isSaving, problem, save } = useGuardedSave();
+	const accept = (value, shareWithTeam) => {
+		if (scope.continuation.contribution.needsShareConsent && !shareWithTeam) {
+			setMode({
+				kind: "sharing",
+				value
+			});
+			return;
+		}
+		save(() => scope.actions.accept({
+			changeId: change.id,
+			shareWithTeam,
+			value
+		}));
+	};
+	return {
+		accept,
+		isSaving,
+		mode,
+		problem,
+		setMode
+	};
+}
+function PendingForm({ acceptance, change, scope }) {
+	const { accept, isSaving, mode, setMode } = acceptance;
+	const idle = () => setMode({ kind: "idle" });
+	if (mode.kind === "sharing") return /* @__PURE__ */ jsx(SharePreview, {
+		confirmation: {
+			isBusy: isSaving,
+			label: "Share and accept",
+			onCancel: idle,
+			onConfirm: () => accept(mode.value, true)
+		},
+		detail: scope.context.detail,
+		extracts: change
+	});
+	if (mode.kind === "editing") return /* @__PURE__ */ jsx(EditedValueForm, {
+		handlers: {
+			onAccept: (value) => accept(value, false),
+			onCancel: idle
+		},
+		initialValue: change.value,
+		isSaving,
+		label: `${FIELD_LABELS[change.field]} (your version)`
+	});
+	return /* @__PURE__ */ jsx(PendingChoices, {
+		handlers: {
+			onAccept: () => accept(null, false),
+			onEdit: () => setMode({ kind: "editing" }),
+			onReject: () => scope.actions.decide(change.id, "rejected")
+		},
+		isSaving
+	});
+}
+function PendingActions({ change, scope }) {
+	const acceptance = useChangeAcceptance(change, scope);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(PendingForm, {
+		acceptance,
+		change,
+		scope
+	}), acceptance.problem && /* @__PURE__ */ jsx(SaveProblemMessage, {
+		onReload: scope.context.review.reload,
+		problem: acceptance.problem
+	})] });
+}
+function ChangeDecision({ change, scope }) {
+	if (change.decision === "accepted") return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: "Accepted"
+	});
+	if (change.decision === "rejected") return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "dt-meta",
+			children: "Rejected"
+		}), scope.context.canEdit && /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: () => scope.actions.decide(change.id, "pending"),
+			type: "button",
+			children: "Undo"
+		})]
+	});
+	return scope.context.canEdit ? /* @__PURE__ */ jsx(PendingActions, {
+		change,
+		scope
+	}) : null;
+}
+function IntentionChangeRow({ change, intention, scope }) {
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-change",
+		"data-decision": change.decision,
+		children: [
+			/* @__PURE__ */ jsxs("div", {
+				className: "dt-ses-chips",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "dt-chip",
+						children: KIND_LABELS$1[change.kind]
+					}),
+					/* @__PURE__ */ jsx("span", {
+						className: "dt-chip",
+						children: FIELD_LABELS[change.field]
+					}),
+					change.hypothesis && /* @__PURE__ */ jsx("span", {
+						className: "dt-chip",
+						"data-tone": "accent",
+						children: "Hypothesis"
+					})
+				]
+			}),
+			/* @__PURE__ */ jsx(ChangeValue, {
+				change,
+				intention
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: change.reason
+			}),
+			/* @__PURE__ */ jsx(ChangeSources, {
+				change,
+				context: scope.context
+			}),
+			/* @__PURE__ */ jsx(ChangeDecision, {
+				change,
+				scope
+			})
+		]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/continuation/use-update-actions.ts
+function withUpdate(detail, update) {
+	return {
+		...detail,
+		continuation: {
+			contribution: update.contribution,
+			intention: update.intention
+		}
+	};
+}
+function useChangeDecisions({ context, continuation }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const { contribution, intention } = continuation;
+	const apply = (update) => context.review.patch((detail) => withUpdate(detail, update));
+	return {
+		accept: async ({ changeId, shareWithTeam, value }) => {
+			const update = await api.acceptIntentionChanges({
+				changes: [value === null ? { changeId } : {
+					changeId,
+					value
+				}],
+				contributionId: contribution.id,
+				expectedRevision: intention?.revision ?? contribution.baseRevision,
+				...shareWithTeam ? { shareWithTeam } : {}
+			});
+			apply(update);
+			announce("Change accepted into the intention");
+		},
+		decide: async (changeId, decision) => {
+			const update = await run("The change was not updated", () => api.reopenOrRejectChange({
+				changeId,
+				contributionId: contribution.id,
+				decision
+			}));
+			if (update) apply(update);
+		}
+	};
+}
+function useReloadingAction(context) {
+	const run = useSessionAction();
+	return async (failureLabel, action) => {
+		if (await run(failureLabel, action) === null) return false;
+		context.review.reload();
+		return true;
+	};
+}
+function useContributionActions({ context, continuation }) {
+	const { api } = useSessionWorkspace();
+	const runThenReload = useReloadingAction(context);
+	const contributionId = continuation.contribution.id;
+	const intentionId = continuation.intention?.id;
+	const sessionId = context.detail.session.id;
+	return {
+		answer: (text) => runThenReload("The answer was not sent", () => api.answerIntentionQuestion({
+			contributionId,
+			text
+		})),
+		detach: async () => {
+			if (await runThenReload("The contribution was not removed", () => api.detachContribution(contributionId))) announce("This session's contribution was removed");
+		},
+		retry: async () => {
+			await runThenReload("The comparison did not restart", () => api.analyze(sessionId));
+		},
+		verify: async (status, note) => {
+			if (intentionId && await runThenReload("The check was not saved", () => api.verifyProposal({
+				note,
+				proposalId: intentionId,
+				sessionId,
+				status
+			}))) announce("Check saved on the intention");
+		}
+	};
+}
+function useUpdateActions(scope) {
+	return {
+		...useChangeDecisions(scope),
+		...useContributionActions(scope)
+	};
+}
+//#endregion
+//#region src/sessions/ui/review/continuation/verdict.tsx
+const VERDICT_LABELS = {
+	insufficient: "Not enough evidence",
+	needs_work: "Still to improve",
+	resolved: "Looks resolved"
+};
+function QuestionBox({ scope }) {
+	const [text, setText] = useState("");
+	const [isSending, setIsSending] = useState(false);
+	const { contribution } = scope.continuation;
+	if (!contribution.question) return null;
+	const send = async () => {
+		setIsSending(true);
+		try {
+			if (await scope.actions.answer(text.trim())) setText("");
+		} finally {
+			setIsSending(false);
+		}
+	};
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-form",
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: "dt-ses-label",
+				children: "Question"
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-note-text",
+				children: contribution.question
+			}),
+			/* @__PURE__ */ jsx("ul", {
+				className: "dt-ses-list",
+				children: contribution.answers.map((answer) => /* @__PURE__ */ jsx("li", { children: answer.text }, answer.at))
+			}),
+			scope.context.canEdit && /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("textarea", {
+				"aria-label": "Your answer",
+				className: "dt-field",
+				maxLength: 1e3,
+				onChange: (event) => setText(event.target.value),
+				rows: 2,
+				value: text
+			}), /* @__PURE__ */ jsx("div", {
+				className: "dt-actions",
+				children: /* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					disabled: isSending || text.trim() === "",
+					onClick: send,
+					type: "button",
+					children: "Send answer"
+				})
+			})] })
+		]
+	});
+}
+function VerdictQuotes({ context, segmentIds }) {
+	const cited = new Set(segmentIds);
+	return context.detail.segments.filter((segment) => cited.has(segment.id)).map((segment) => /* @__PURE__ */ jsxs("button", {
+		className: "dt-ses-quote",
+		onClick: (event) => context.navigation.onShowMoment(segment.id, event.currentTarget),
+		type: "button",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "dt-ses-time",
+			children: formatClock(segment.startMs)
+		}), ` “${segment.text}”`]
+	}, segment.id));
+}
+const CHECK_LABELS = {
+	needs_work: "needs more work",
+	works: "works"
+};
+function VerdictBox({ scope }) {
+	const { actions, context, continuation } = scope;
+	const { verdict } = continuation.contribution;
+	if (!verdict) return null;
+	const verification = continuation.intention?.verification;
+	const checkedHere = verification?.sessionId === context.detail.session.id ? verification : null;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-form",
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: "dt-ses-label",
+				children: "AI reading"
+			}),
+			/* @__PURE__ */ jsxs("p", { children: [
+				/* @__PURE__ */ jsx("span", {
+					className: "dt-chip",
+					children: VERDICT_LABELS[verdict.status]
+				}),
+				" ",
+				verdict.reason
+			] }),
+			/* @__PURE__ */ jsx(VerdictQuotes, {
+				context,
+				segmentIds: verdict.segmentIds
+			}),
+			checkedHere && /* @__PURE__ */ jsxs("p", {
+				className: "dt-meta",
+				role: "status",
+				children: [
+					"You confirmed it ",
+					CHECK_LABELS[checkedHere.status],
+					" on",
+					" ",
+					formatDate(checkedHere.at),
+					"."
+				]
+			}),
+			context.canEdit && /* @__PURE__ */ jsxs("div", {
+				className: "dt-actions",
+				children: [/* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					onClick: () => actions.verify("works", verdict.reason),
+					type: "button",
+					children: "Confirm: works"
+				}), /* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					onClick: () => actions.verify("needs_work", verdict.reason),
+					type: "button",
+					children: "Confirm: needs more work"
+				})]
+			})
+		]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/continuation/update-card.tsx
+const DETACH_COPY = "Remove what this session added to the intention? Each field that still holds the value this session set goes back to its previous value. Fields changed since then are kept, and the intention is marked to re-examine.";
+const INTENTION_DELETED = "The intention this session continued was deleted. This session stays as it was recorded.";
+const INTENTION_HIDDEN = "The intention this session continued is no longer visible to you.";
+function ContinuationHeader({ continuation, onOpenSession }) {
+	const { contribution, intention } = continuation;
+	if (!intention) return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: contribution.detachedAt === null ? INTENTION_HIDDEN : INTENTION_DELETED
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsxs("p", { children: [
+			"Continues “",
+			intention.need,
+			"”"
+		] }), /* @__PURE__ */ jsx("div", {
+			className: "dt-actions",
+			children: /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: () => onOpenSession(intention.sessionId),
+				type: "button",
+				children: "Open the intention"
+			})
+		})]
+	});
+}
+function ContributionState({ scope }) {
+	const { actions, context, continuation } = scope;
+	const { contribution } = continuation;
+	if (contribution.state === "recording") return /* @__PURE__ */ jsx("p", {
+		className: "dt-status",
+		children: "This session is still recording. What it changes appears once it ends."
+	});
+	if (contribution.state === "analyzing") return /* @__PURE__ */ jsxs("p", {
+		className: "dt-status",
+		children: [
+			"Comparing with revision ",
+			contribution.baseRevision,
+			"…"
+		]
+	});
+	if (contribution.state === "no_change") return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: "No change to the intention"
+	});
+	if (contribution.state !== "failed") return null;
+	const reason = context.detail.session.analysis.error ?? "Unknown error.";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		role: "alert",
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: "dt-error",
+			children: ["The comparison failed: ", reason]
+		}), context.canEdit && /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: actions.retry,
+			type: "button",
+			children: "Try again"
+		})]
+	});
+}
+function DetachContribution({ scope }) {
+	const [isConfirming, setIsConfirming] = useState(false);
+	if (!isConfirming) return /* @__PURE__ */ jsx("div", {
+		className: "dt-actions",
+		children: /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			"data-variant": "danger",
+			onClick: () => setIsConfirming(true),
+			type: "button",
+			children: "Remove this session's contribution"
+		})
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsx("p", { children: DETACH_COPY }), /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				"data-variant": "danger",
+				onClick: scope.actions.detach,
+				type: "button",
+				children: "Remove contribution"
+			}), /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: () => setIsConfirming(false),
+				type: "button",
+				children: "Cancel"
+			})]
+		})]
+	});
+}
+function ContributionBody({ intention, scope }) {
+	const { contribution } = scope.continuation;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(ContributionState, { scope }),
+		contribution.stale && /* @__PURE__ */ jsxs("p", {
+			className: "dt-ses-banner",
+			role: "status",
+			children: [
+				"The intention changed since this comparison: it is now at revision",
+				" ",
+				intention.revision,
+				". Check each change against it."
+			]
+		}),
+		contribution.state === "ready" && /* @__PURE__ */ jsx("ul", {
+			className: "dt-ses-rows",
+			children: contribution.changes.map((change) => /* @__PURE__ */ jsx(IntentionChangeRow, {
+				change,
+				intention,
+				scope
+			}, change.id))
+		}),
+		/* @__PURE__ */ jsx(QuestionBox, { scope }),
+		/* @__PURE__ */ jsx(VerdictBox, { scope }),
+		/* @__PURE__ */ jsx(AppliedChanges, { applied: contribution.applied }),
+		scope.context.canEdit && /* @__PURE__ */ jsx(DetachContribution, { scope })
+	] });
+}
+function UpdateCard({ context, continuation }) {
+	const headingId = useId();
+	const actions = useUpdateActions({
+		context,
+		continuation
+	});
+	const { contribution, intention } = continuation;
+	if (!intention) return null;
+	const scope = {
+		actions,
+		context,
+		continuation
+	};
+	return /* @__PURE__ */ jsxs("article", {
+		"aria-labelledby": headingId,
+		className: "dt-card",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "dt-ses-subhead",
+			id: headingId,
+			children: "What changes"
+		}), contribution.detachedAt === null ? /* @__PURE__ */ jsx(ContributionBody, {
+			intention,
+			scope
+		}) : /* @__PURE__ */ jsx("p", {
+			className: "dt-meta",
+			children: "This session's contribution was removed from the intention."
+		})]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/transcript/remove-evidence.tsx
+const REMOVE_COPY = "Remove this screenshot? The image is deleted for good. Briefs you already copied or exported can't be recalled.";
+function useFocusWhen(shouldFocus) {
+	const ref = useRef(null);
+	useEffect(() => {
+		if (shouldFocus) ref.current?.focus();
+	}, [shouldFocus]);
+	return ref;
+}
+function RemoveConfirmation({ evidence, onCancel, removal }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const cancelRef = useFocusWhen(true);
+	const remove = async () => {
+		const removed = await run("The screenshot was not removed", () => api.removeEvidence(evidence.id));
+		if (removed !== null) {
+			removal.review.patch((detail) => withEvidence(detail, removed));
+			removal.onRemoved(removed.id);
+			announce("Screenshot removed");
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsx("p", { children: REMOVE_COPY }), /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				"data-variant": "danger",
+				onClick: remove,
+				type: "button",
+				children: "Remove"
+			}), /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onCancel,
+				ref: cancelRef,
+				type: "button",
+				children: "Cancel"
+			})]
+		})]
+	});
+}
+function RemoveEvidence({ evidence, removal }) {
+	const [isConfirming, setIsConfirming] = useState(false);
+	const [hasCancelled, setHasCancelled] = useState(false);
+	const triggerRef = useFocusWhen(hasCancelled);
+	if (isConfirming) return /* @__PURE__ */ jsx(RemoveConfirmation, {
+		evidence,
+		onCancel: () => {
+			setIsConfirming(false);
+			setHasCancelled(true);
+		},
+		removal
+	});
+	return /* @__PURE__ */ jsx("button", {
+		"aria-label": `Remove screenshot at ${formatClock(evidence.atMs)}`,
+		className: "dt-ses-link",
+		onClick: () => {
+			setIsConfirming(true);
+			setHasCancelled(false);
+		},
+		ref: triggerRef,
+		type: "button",
+		children: "Remove"
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/moment/moment-labels.ts
+const URL_PATH = /^[a-z][a-z\d+.-]*:\/\/[^/?#]*([^?#]*)/i;
+const KIND_LABELS = {
+	click: "Clicked",
+	mark: "Marked",
+	navigation: "Opened page",
+	screenshot: "Screenshot",
+	select: "Pointed at explicitly"
+};
+const ORIGIN_LABELS = {
+	auto: "Linked automatically",
+	human: "Corrected by you",
+	unknown: "Context unknown"
+};
+function contextKindLabel(item) {
+	if (item.kind === "dwell") return `Hovered ${preciseSeconds(item.durationMs ?? 0)}`;
+	return KIND_LABELS[item.kind];
+}
+function pagePath(url) {
+	if (!url) return null;
+	return URL_PATH.exec(url)?.[1] || "/";
+}
+function contextLine(item) {
+	const page = pagePath(item.url ?? item.frame?.url ?? null);
+	const element = item.element?.label ?? item.label;
+	return page ? `${element} · ${page}` : element;
+}
+function offsetFromPassage(atMs, segment) {
+	if (atMs < segment.startMs) return `${preciseSeconds(segment.startMs - atMs)} before`;
+	if (atMs > segment.endMs) return `${preciseSeconds(atMs - segment.endMs)} after`;
+	return "during the passage";
+}
+const distanceFrom = (atMs, segment) => Math.max(segment.startMs - atMs, 0, atMs - segment.endMs);
+function nearestSegmentId(segments, atMs) {
+	let nearest = null;
+	for (const segment of segments) if (!nearest || distanceFrom(atMs, segment) < distanceFrom(atMs, nearest)) nearest = segment;
+	return nearest?.id ?? null;
+}
+function gapsDuring(gaps, segment) {
+	return gaps.filter((gap) => gap.startMs <= segment.endMs && (gap.endMs ?? Number.POSITIVE_INFINITY) >= segment.startMs);
+}
+//#endregion
+//#region src/sessions/ui/review/transcript/segment-row.tsx
+function SaveCancelActions({ isSaveDisabled, onCancel, onSave }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			"data-variant": "primary",
+			disabled: isSaveDisabled,
+			onClick: onSave,
+			type: "button",
+			children: "Save"
+		}), /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: onCancel,
+			type: "button",
+			children: "Cancel"
+		})]
+	});
+}
+function SegmentEditor({ onDone, review, segment }) {
+	const { api } = useSessionWorkspace();
+	const { isSaving, problem, save } = useGuardedSave();
+	const [text, setText] = useState(segment.text);
+	const submit = () => save(async () => {
+		const saved = await api.correctSegment({
+			expectedRevision: segment.revision,
+			segmentId: segment.id,
+			text: text.trim()
+		});
+		review.patch((detail) => withSegment(detail, saved));
+		review.reload();
+		onDone();
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-form",
+		children: [
+			/* @__PURE__ */ jsx("textarea", {
+				"aria-label": `Passage at ${formatClock(segment.startMs)}`,
+				className: "dt-field",
+				maxLength: 5e3,
+				onChange: (event) => setText(event.target.value),
+				rows: 3,
+				value: text
+			}),
+			problem && /* @__PURE__ */ jsx(SaveProblemMessage, {
+				onReload: review.reload,
+				problem
+			}),
+			/* @__PURE__ */ jsx(SaveCancelActions, {
+				isSaveDisabled: isSaving || text.trim() === "",
+				onCancel: onDone,
+				onSave: submit
+			})
+		]
+	});
+}
+function SegmentBody({ onType, review, segment }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const { state } = segment.transcription;
+	const retry = async () => {
+		const pending = await run("The transcription did not restart", () => api.retrySegment(segment.id));
+		if (pending) review.patch((detail) => withSegment(detail, pending));
+	};
+	if (state === "pending" || state === "running") return /* @__PURE__ */ jsx("p", {
+		className: "dt-status",
+		children: "Transcribing…"
+	});
+	if (state === "failed" || state === "expired") return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [
+			/* @__PURE__ */ jsx("p", {
+				className: "dt-error",
+				children: state === "failed" ? "Couldn't transcribe" : "Audio expired — type what you said"
+			}),
+			onType && state === "failed" && segment.hasAudio && /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: retry,
+				type: "button",
+				children: "Retry"
+			}),
+			onType && /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onType,
+				type: "button",
+				children: "Type it"
+			})
+		]
+	});
+	if (state === "empty" && segment.text === "") return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: "No speech was heard here."
+	});
+	return /* @__PURE__ */ jsx("p", {
+		className: "dt-note-text",
+		children: segment.text
+	});
+}
+function ContextChips({ segment }) {
+	if (segment.context.length === 0) return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-chips",
+		children: [segment.contextAmbiguous && /* @__PURE__ */ jsx("span", {
+			className: "dt-chip",
+			children: "Unclear which element"
+		}), segment.context.map((item) => /* @__PURE__ */ jsx("span", {
+			className: "dt-chip",
+			children: item.label
+		}, `${item.kind}:${item.atMs}:${item.label}`))]
+	});
+}
+function SegmentLinks({ onEdit, onShowMoment, time }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsx("button", {
+			"aria-label": `Show context at ${time}`,
+			className: "dt-ses-link",
+			onClick: (event) => onShowMoment(event.currentTarget),
+			type: "button",
+			children: "Show context"
+		}), onEdit && /* @__PURE__ */ jsx("button", {
+			"aria-label": `Edit passage at ${time}`,
+			className: "dt-ses-link",
+			onClick: onEdit,
+			type: "button",
+			children: "Edit"
+		})]
+	});
+}
+function SegmentRow({ editing, onShowMoment, segment }) {
+	const { canEdit, review } = editing;
+	const [isEditing, setIsEditing] = useState(false);
+	const time = formatClock(segment.startMs);
+	const isSettled = ["done", "empty"].includes(segment.transcription.state);
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-seg",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "dt-ses-time",
+			children: time
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "dt-ses-seg-body",
+			children: [
+				isEditing ? /* @__PURE__ */ jsx(SegmentEditor, {
+					onDone: () => setIsEditing(false),
+					review,
+					segment
+				}) : /* @__PURE__ */ jsx(SegmentBody, {
+					onType: canEdit ? () => setIsEditing(true) : void 0,
+					review,
+					segment
+				}),
+				/* @__PURE__ */ jsx(ContextChips, { segment }),
+				/* @__PURE__ */ jsx(SegmentLinks, {
+					onEdit: canEdit && isSettled && !isEditing ? () => setIsEditing(true) : null,
+					onShowMoment,
+					time
+				})
+			]
+		})]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/transcript/transcript-tab.tsx
+const GAP_LABELS = {
+	hidden: "Tab hidden",
+	interrupted: "Interrupted",
+	limit: "Time limit reached",
+	paused: "Paused"
+};
+function gapLabel(gap) {
+	const label = GAP_LABELS[gap.reason];
+	return gap.endMs === null ? label : `${label} · ${shortDuration(gap.endMs - gap.startMs)}`;
+}
+function markLabel(mark) {
+	const note = mark.note ? ` — ${mark.note}` : "";
+	if (mark.kind === "navigation") return `Went to ${mark.url ?? mark.label}`;
+	return `${mark.kind === "select" ? "Pointed at" : "Marked a moment on"} ${mark.label}${note}`;
+}
+function TimelineNote({ atMs, children, onShowMoment }) {
+	const time = formatClock(atMs);
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-seg",
+		"data-kind": "note",
+		children: [/* @__PURE__ */ jsx("span", {
+			className: "dt-ses-time",
+			children: time
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "dt-ses-seg-body",
+			children: [/* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children
+			}), onShowMoment && /* @__PURE__ */ jsx("button", {
+				"aria-label": `Show the moment at ${time}`,
+				className: "dt-ses-link",
+				onClick: (event) => onShowMoment(event.currentTarget),
+				type: "button",
+				children: "Show moment"
+			})]
+		})]
+	});
+}
+function buildTimeline(detail) {
+	return [
+		...detail.segments.map((segment) => ({
+			atMs: segment.startMs,
+			key: `s:${segment.id}`,
+			segment
+		})),
+		...detail.session.gaps.map((gap) => ({
+			atMs: gap.startMs,
+			key: `g:${gap.startMs}`,
+			label: gapLabel(gap),
+			segmentId: null
+		})),
+		...detail.marks.map((mark) => ({
+			atMs: mark.atMs,
+			key: `m:${mark.kind}:${mark.atMs}`,
+			label: markLabel(mark),
+			segmentId: nearestSegmentId(detail.segments, mark.atMs)
+		}))
+	].sort((earlier, later) => earlier.atMs - later.atMs);
+}
+function noteMomentOpener(segmentId, onShowMoment) {
+	if (!segmentId) return null;
+	return (opener) => onShowMoment(segmentId, opener);
+}
+function useTypedPassage({ detail, review }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const [text, setText] = useState("");
+	const [clientKey, setClientKey] = useState(() => crypto.randomUUID());
+	const atMs = detail.segments.at(-1)?.endMs ?? 0;
+	const add = async () => {
+		const segment = await run("The passage was not added", () => api.addTypedSegment({
+			clientKey,
+			endMs: atMs,
+			sessionId: detail.session.id,
+			startMs: atMs,
+			text: text.trim()
+		}));
+		if (segment) {
+			review.patch((current) => withSegment(current, segment));
+			setText("");
+			setClientKey(crypto.randomUUID());
+		}
+	};
+	return {
+		add,
+		setText,
+		text
+	};
+}
+function AddTypedPassage({ detail, review }) {
+	const { add, setText, text } = useTypedPassage({
+		detail,
+		review
+	});
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-form",
+		children: [/* @__PURE__ */ jsx("textarea", {
+			"aria-label": "Add a typed passage",
+			className: "dt-field",
+			maxLength: 5e3,
+			onChange: (event) => setText(event.target.value),
+			placeholder: "Add a typed passage",
+			rows: 2,
+			value: text
+		}), /* @__PURE__ */ jsx("div", {
+			className: "dt-actions",
+			children: /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				disabled: text.trim() === "",
+				onClick: add,
+				type: "button",
+				children: "Add passage"
+			})
+		})]
+	});
+}
+function TranscriptTab({ detail, onShowMoment, review }) {
+	const { canEdit } = detail.session;
+	const timeline = buildTimeline(detail);
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("p", {
+			className: "dt-hint",
+			children: "Audio is deleted once transcribed. You can still correct the text."
+		}),
+		timeline.length === 0 && /* @__PURE__ */ jsx("p", {
+			className: "dt-empty",
+			children: "Nothing was said in this session."
+		}),
+		/* @__PURE__ */ jsx("ol", {
+			className: "dt-ses-timeline",
+			children: timeline.map((item) => "segment" in item ? /* @__PURE__ */ jsx(SegmentRow, {
+				editing: {
+					canEdit,
+					review
+				},
+				onShowMoment: (opener) => onShowMoment(item.segment.id, opener),
+				segment: item.segment
+			}, item.key) : /* @__PURE__ */ jsx(TimelineNote, {
+				atMs: item.atMs,
+				onShowMoment: noteMomentOpener(item.segmentId, onShowMoment),
+				children: item.label
+			}, item.key))
+		}),
+		canEdit && /* @__PURE__ */ jsx(AddTypedPassage, {
+			detail,
+			review
+		})
+	] });
+}
+//#endregion
+//#region src/sessions/ui/review/moment/context-correction.tsx
+const AUTO_CHOICE = { kind: "auto" };
+const UNKNOWN_CHOICE = { kind: "unknown" };
+function useContextChoices(segmentId) {
+	const { api, onUnauthorized } = useSessionWorkspace();
+	const [state, setState] = useState({ kind: "loading" });
+	useEffect(() => {
+		let isCurrent = true;
+		api.contextChoices(segmentId).then((options) => isCurrent && setState({
+			kind: "ready",
+			options
+		}), (error) => {
+			if (isUnauthorized(error)) onUnauthorized();
+			else if (isCurrent) setState({
+				kind: "failed",
+				message: failureMessage(error)
+			});
+		});
+		return () => {
+			isCurrent = false;
+		};
+	}, [
+		api,
+		onUnauthorized,
+		segmentId
+	]);
+	return state;
+}
+function ChoiceRadio({ choice, group, label }) {
+	return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("label", {
+		className: "dt-ses-check",
+		children: [/* @__PURE__ */ jsx("input", {
+			checked: group.chosen === choice,
+			name: group.name,
+			onChange: () => group.onPick(choice),
+			type: "radio"
+		}), /* @__PURE__ */ jsx("span", { children: label })]
+	}) });
+}
+function optionLabel(option, segment) {
+	const { item } = option;
+	const element = item.element?.label ?? item.label;
+	return `${contextKindLabel(item)} · ${element} · ${offsetFromPassage(item.atMs, segment)}`;
+}
+function ChoicesFieldset({ group, options, segment }) {
+	return /* @__PURE__ */ jsxs("fieldset", {
+		className: "dt-ses-choices",
+		children: [/* @__PURE__ */ jsx("legend", {
+			className: "dt-ses-label",
+			children: "What this passage is about"
+		}), /* @__PURE__ */ jsxs("ul", {
+			className: "dt-ses-list",
+			children: [
+				options.map((option) => /* @__PURE__ */ jsx(ChoiceRadio, {
+					choice: option.choice,
+					group,
+					label: optionLabel(option, segment)
+				}, JSON.stringify(option.choice))),
+				/* @__PURE__ */ jsx(ChoiceRadio, {
+					choice: UNKNOWN_CHOICE,
+					group,
+					label: "Context unknown"
+				}),
+				segment.contextOrigin !== "auto" && /* @__PURE__ */ jsx(ChoiceRadio, {
+					choice: AUTO_CHOICE,
+					group,
+					label: "Back to automatic"
+				})
+			]
+		})]
+	});
+}
+function useSaveContext(correction, chosen) {
+	const { onDone, review, segment } = correction;
+	const { api } = useSessionWorkspace();
+	const { isSaving, problem, save } = useGuardedSave();
+	const submit = () => save(async () => {
+		if (!chosen) return;
+		const saved = await api.setSegmentContext({
+			choice: chosen,
+			expectedRevision: segment.revision,
+			segmentId: segment.id
+		});
+		review.patch((detail) => withSegment(detail, saved));
+		announce("Context corrected");
+		onDone();
+	});
+	return {
+		isSaving,
+		problem,
+		submit
+	};
+}
+function ChoicesForm({ correction, options }) {
+	const { onDone, review, segment } = correction;
+	const [picked, setPicked] = useState(null);
+	const current = options.find((option) => option.selected)?.choice ?? (segment.contextOrigin === "unknown" ? UNKNOWN_CHOICE : null);
+	const chosen = picked ?? current;
+	const { isSaving, problem, submit } = useSaveContext(correction, chosen);
+	return /* @__PURE__ */ jsxs("form", {
+		className: "dt-ses-form",
+		onSubmit: (event) => {
+			event.preventDefault();
+			submit();
+		},
+		children: [
+			/* @__PURE__ */ jsx(ChoicesFieldset, {
+				group: {
+					chosen,
+					name: `rf-context-${segment.id}`,
+					onPick: setPicked
+				},
+				options,
+				segment
+			}),
+			problem && /* @__PURE__ */ jsx(SaveProblemMessage, {
+				onReload: review.reload,
+				problem
+			}),
+			/* @__PURE__ */ jsx(FormActions, {
+				isSubmitDisabled: isSaving || picked === null,
+				onCancel: onDone,
+				submitLabel: "Save context"
+			})
+		]
+	});
+}
+function ContextChoices({ correction, onRetry }) {
+	const state = useContextChoices(correction.segment.id);
+	if (state.kind === "loading") return /* @__PURE__ */ jsx("p", {
+		className: "dt-status",
+		children: "Loading what was happening…"
+	});
+	if (state.kind === "failed") return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		role: "alert",
+		children: [
+			/* @__PURE__ */ jsxs("p", {
+				className: "dt-error",
+				children: ["The choices did not load: ", state.message]
+			}),
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onRetry,
+				type: "button",
+				children: "Try again"
+			}),
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: correction.onDone,
+				type: "button",
+				children: "Cancel"
+			})
+		]
+	});
+	return /* @__PURE__ */ jsx(ChoicesForm, {
+		correction,
+		options: state.options
+	});
+}
+function ContextCorrection({ review, segment }) {
+	const [isOpen, setIsOpen] = useState(false);
+	const [hasClosed, setHasClosed] = useState(false);
+	const [attempt, setAttempt] = useState(0);
+	const buttonRef = useFocusWhen(hasClosed && !isOpen);
+	if (isOpen) return /* @__PURE__ */ jsx(ContextChoices, {
+		correction: {
+			onDone: () => {
+				setIsOpen(false);
+				setHasClosed(true);
+			},
+			review,
+			segment
+		},
+		onRetry: () => setAttempt(attempt + 1)
+	}, attempt);
+	return /* @__PURE__ */ jsx("button", {
+		className: "dt-btn",
+		onClick: () => {
+			setIsOpen(true);
+			setHasClosed(false);
+		},
+		ref: buttonRef,
+		type: "button",
+		children: "Change context"
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/moment/moment-screenshot.tsx
+const OTHER_STATE_CAPTION = "This screenshot was not taken at this moment: it may show another state of the page.";
+function approximateCaption(offsetMs) {
+	if (offsetMs === null) return "Approximate — screenshot taken at another moment";
+	const direction = offsetMs >= 0 ? "after" : "before";
+	return `Approximate — screenshot taken ${preciseSeconds(offsetMs)} ${direction}`;
+}
+function overlayFor(item) {
+	const { element, evidenceMatch, frame, pointer } = item;
+	if (!(evidenceMatch && frame)) return null;
+	const outline = element ? percentBox(element.rect, frame) : null;
+	const dot = evidenceMatch === "exact" && pointer ? percentPoint(pointer, frame) : null;
+	return outline ? {
+		dot,
+		match: evidenceMatch,
+		outline
+	} : null;
+}
+function screenshotAlt(item, evidence) {
+	const time = formatClock(evidence.capturedAtMs ?? evidence.atMs);
+	const element = item.element?.label;
+	if (!(element && overlayFor(item))) return `Screenshot at ${time}`;
+	return `Screenshot at ${time}, “${element}” outlined${item.evidenceMatch === "approximate" ? " approximately" : ""}`;
+}
+function screenshotCaption(item) {
+	if (item.evidenceMatch === "approximate") return approximateCaption(item.evidenceOffsetMs);
+	return item.evidenceMatch === "exact" ? null : OTHER_STATE_CAPTION;
+}
+function MissingScreenshot({ evidence }) {
+	const reason = evidence?.missingReason;
+	return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: reason ? `Screenshot removed: ${reason}` : "Screenshot removed"
+	});
+}
+function MomentScreenshot({ evidence, item }) {
+	const image = evidence?.status === "available" ? evidence.image : null;
+	if (!(evidence && image?.url)) return /* @__PURE__ */ jsx(MissingScreenshot, { evidence });
+	const overlay = overlayFor(item);
+	const caption = screenshotCaption(item);
+	return /* @__PURE__ */ jsxs("figure", {
+		className: "dt-ses-moment-shot",
+		children: [/* @__PURE__ */ jsxs("span", {
+			className: "dt-ses-shot",
+			"data-large": "true",
+			children: [
+				/* @__PURE__ */ jsx("img", {
+					alt: screenshotAlt(item, evidence),
+					height: image.height,
+					src: image.url,
+					width: image.width
+				}),
+				overlay && /* @__PURE__ */ jsx("span", {
+					"aria-hidden": "true",
+					className: "dt-ses-shot-mark",
+					"data-match": overlay.match,
+					style: overlay.outline
+				}),
+				overlay?.dot && /* @__PURE__ */ jsx("span", {
+					"aria-hidden": "true",
+					className: "dt-ses-shot-pointer",
+					style: overlay.dot
+				})
+			]
+		}), caption && /* @__PURE__ */ jsx("figcaption", {
+			className: "dt-meta",
+			children: caption
+		})]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/moment/moment-view.tsx
+const AMBIGUOUS_COPY = "Several things happened around this passage. Reflet linked the closest one: check it, or change it.";
+function ContextItem({ detail, item }) {
+	const evidence = detail.evidence.find((candidate) => candidate.id === item.evidenceId) ?? null;
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-ses-moment-item",
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: "dt-ses-moment-line",
+			children: [/* @__PURE__ */ jsx("span", {
+				className: "dt-chip",
+				children: contextKindLabel(item)
+			}), /* @__PURE__ */ jsx("span", { children: contextLine(item) })]
+		}), item.evidenceId && /* @__PURE__ */ jsx(MomentScreenshot, {
+			evidence,
+			item
+		})]
+	});
+}
+function MomentContext({ detail, segment }) {
+	const hasScreenshot = segment.context.some((item) => item.evidenceId);
+	const isAmbiguous = segment.contextAmbiguous && segment.contextOrigin === "auto";
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-moment-section",
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: "dt-ses-label",
+				children: "On the page"
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "dt-ses-chips",
+				children: /* @__PURE__ */ jsx("span", {
+					className: "dt-chip",
+					children: ORIGIN_LABELS[segment.contextOrigin]
+				})
+			}),
+			isAmbiguous && /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: AMBIGUOUS_COPY
+			}),
+			segment.context.length === 0 && /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: "Nothing on the page is linked to this passage."
+			}),
+			/* @__PURE__ */ jsx("ul", {
+				className: "dt-ses-rows",
+				children: segment.context.map((item) => /* @__PURE__ */ jsx(ContextItem, {
+					detail,
+					item
+				}, `${item.kind}:${item.atMs}:${item.label}`))
+			}),
+			!hasScreenshot && /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: "No screenshot at this moment"
+			})
+		]
+	});
+}
+function MomentNotices({ detail, segment }) {
+	const gaps = gapsDuring(detail.session.gaps, segment);
+	const hasPageChange = segment.context.some((item) => item.kind === "navigation");
+	if (gaps.length === 0 && !hasPageChange) return null;
+	return /* @__PURE__ */ jsxs("ul", {
+		className: "dt-ses-list dt-ses-moment-notices",
+		children: [gaps.map((gap) => /* @__PURE__ */ jsxs("li", { children: [gapLabel(gap), " during this passage: part of what happened was not recorded."] }, gap.startMs)), hasPageChange && /* @__PURE__ */ jsx("li", { children: "The page changed during this passage." })]
+	});
+}
+function CitingIntentions({ detail, onOpenIntention, segmentId }) {
+	const citing = detail.proposals.filter((proposal) => proposal.mergedIntoId === null && proposal.segmentIds.includes(segmentId));
+	if (citing.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-moment-section",
+		children: [/* @__PURE__ */ jsx("h4", {
+			className: "dt-ses-label",
+			children: "Intentions citing this passage"
+		}), /* @__PURE__ */ jsx("ul", {
+			className: "dt-ses-rows",
+			children: citing.map((proposal) => /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsx("button", {
+				className: "dt-ses-row",
+				onClick: () => onOpenIntention(proposal.id),
+				type: "button",
+				children: proposal.need
+			}) }, proposal.id))
+		})]
+	});
+}
+function MomentSteps({ detail, onShowMoment, segmentId }) {
+	const ordered = [...detail.segments].sort((a, b) => a.startMs - b.startMs);
+	const index = ordered.findIndex((segment) => segment.id === segmentId);
+	const previous = ordered[index - 1];
+	const next = ordered[index + 1];
+	return /* @__PURE__ */ jsxs("nav", {
+		"aria-label": "Moments",
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			disabled: !previous,
+			onClick: () => previous && onShowMoment(previous.id),
+			type: "button",
+			children: "Previous moment"
+		}), /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			disabled: !next,
+			onClick: () => next && onShowMoment(next.id),
+			type: "button",
+			children: "Next moment"
+		})]
+	});
+}
+function MomentHeading({ onClose, segment }) {
+	const headingRef = useFocusWhen(true);
+	const range = segment ? `${formatClock(segment.startMs)}–${formatClock(segment.endMs)}` : "";
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-card-head",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "dt-ses-title",
+			ref: headingRef,
+			tabIndex: -1,
+			children: segment ? `Moment ${range}` : "Moment"
+		}), /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: onClose,
+			type: "button",
+			children: "Close"
+		})]
+	});
+}
+function useEscapeToClose(onClose) {
+	const sectionRef = useRef(null);
+	const onCloseRef = useRef(onClose);
+	useLayoutEffect(() => {
+		onCloseRef.current = onClose;
+	});
+	useEffect(() => {
+		const section = sectionRef.current;
+		const closeOnEscape = (event) => {
+			if (event.key === "Escape") {
+				event.stopPropagation();
+				onCloseRef.current();
+			}
+		};
+		section?.addEventListener("keydown", closeOnEscape);
+		return () => section?.removeEventListener("keydown", closeOnEscape);
+	}, []);
+	return sectionRef;
+}
+function MomentView({ handlers, segmentId, session }) {
+	const { detail, review } = session;
+	const segment = detail.segments.find((item) => item.id === segmentId);
+	const sectionRef = useEscapeToClose(handlers.onClose);
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-label": "Moment",
+		className: "dt-ses-moment",
+		ref: sectionRef,
+		children: [
+			/* @__PURE__ */ jsx(MomentHeading, {
+				onClose: handlers.onClose,
+				segment: segment ?? null
+			}, segmentId),
+			segment ? /* @__PURE__ */ jsxs(Fragment, { children: [
+				/* @__PURE__ */ jsx("blockquote", {
+					className: "dt-ses-moment-quote",
+					children: segment.text || "No speech was heard here."
+				}),
+				/* @__PURE__ */ jsx(MomentContext, {
+					detail,
+					segment
+				}),
+				/* @__PURE__ */ jsx(MomentNotices, {
+					detail,
+					segment
+				}),
+				/* @__PURE__ */ jsx(CitingIntentions, {
+					detail,
+					onOpenIntention: handlers.onOpenIntention,
+					segmentId: segment.id
+				}),
+				detail.session.canEdit && /* @__PURE__ */ jsx(ContextCorrection, {
+					review,
+					segment
+				})
+			] }) : /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: "This passage is no longer in the session."
+			}),
+			/* @__PURE__ */ jsx(MomentSteps, {
+				detail,
+				onShowMoment: handlers.onShowMoment,
+				segmentId
+			})
+		]
+	});
+}
+//#endregion
+//#region src/sessions/ui/start/session-disclosure.tsx
+const SEEN_KEY_PREFIX = "reflet-sessions-disclosure:";
+function hasSeenDisclosure(accountKey) {
+	try {
+		return localStorage.getItem(`${SEEN_KEY_PREFIX}${accountKey}`) !== null;
+	} catch {
+		return false;
+	}
+}
+function markDisclosureSeen(accountKey) {
+	try {
+		localStorage.setItem(`${SEEN_KEY_PREFIX}${accountKey}`, "1");
+	} catch {}
+}
+function DisclosureList() {
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-labelledby": "rf-session-disclosure",
+		className: "dt-hint",
+		children: [/* @__PURE__ */ jsx("h3", {
+			className: "dt-ses-subhead",
+			id: "rf-session-disclosure",
+			children: "What a session records"
+		}), /* @__PURE__ */ jsxs("ul", {
+			className: "dt-ses-list",
+			children: [
+				/* @__PURE__ */ jsx("li", { children: "Your voice while recording. It is sent to Reflet and transcribed by Whisper through OpenRouter with zero data retention. The audio is deleted as soon as its transcript is saved, within 24 hours at most." }),
+				/* @__PURE__ */ jsx("li", { children: "The page: its address without sensitive parameters, its title, the scroll position and the window size." }),
+				/* @__PURE__ */ jsx("li", { children: "What you click, point at and mark: element names and positions, never your keystrokes." }),
+				/* @__PURE__ */ jsxs("li", { children: [
+					"Screenshots of this tab at the start, when you mark a moment and when the page changes. Form fields appear empty; password fields and elements marked ",
+					/* @__PURE__ */ jsx("code", { children: "data-reflet-redact" }),
+					" are hidden. Other text on screen, rich-text editors included, stays visible."
+				] }),
+				/* @__PURE__ */ jsx("li", { children: "Not recorded: keystrokes, other tabs or apps, network calls." }),
+				/* @__PURE__ */ jsx("li", { children: "Pausing stops everything." }),
+				/* @__PURE__ */ jsx("li", { children: "A session stays private to you until you share it." })
+			]
+		})]
+	});
+}
+function SessionDisclosure({ accountKey }) {
+	const [isOpen, setIsOpen] = useState(() => !hasSeenDisclosure(accountKey));
+	if (isOpen) return /* @__PURE__ */ jsx(DisclosureList, {});
+	return /* @__PURE__ */ jsx("button", {
+		"aria-expanded": false,
+		className: "dt-ses-link",
+		onClick: () => setIsOpen(true),
+		type: "button",
+		children: "What a session records"
+	});
+}
+//#endregion
+//#region src/sessions/ui/start/start-session.tsx
+const IS_MICROPHONE_FAILURE = {
+	auth: false,
+	insecure_context: true,
+	limit: false,
+	mic_blocked_by_site: true,
+	mic_denied: true,
+	mic_unavailable: true,
+	network: false,
+	storage: false
+};
+function StartProblem({ failure, onRetry, onWriteNote }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-problem",
+		role: "alert",
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "dt-error",
+			children: failure.message
+		}), /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onRetry,
+				type: "button",
+				children: "Try again"
+			}), IS_MICROPHONE_FAILURE[failure.kind] && onWriteNote && /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onWriteNote,
+				type: "button",
+				children: "Write a note instead"
+			})]
+		})]
+	});
+}
+function StartActions({ isBusy, onStart, onWriteNote }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			"data-variant": "primary",
+			disabled: isBusy,
+			onClick: onStart,
+			type: "button",
+			children: "Start session"
+		}), onWriteNote && /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: onWriteNote,
+			type: "button",
+			children: "Write a note instead"
+		})]
+	});
+}
+function useRecorderStart(onStarted) {
+	const { account, recorder } = useSessionWorkspace();
+	const snapshot = useRecorderSnapshot(recorder);
+	const [hasTried, setHasTried] = useState(false);
+	const start = async (options) => {
+		markDisclosureSeen(account.key);
+		setHasTried(true);
+		await recorder.start(options);
+		if (recorder.getSnapshot().phase === "recording") onStarted();
+	};
+	const isRequesting = snapshot.phase === "requesting";
+	return {
+		failure: hasTried && snapshot.phase === "failed" && snapshot.sessionKey === null ? snapshot.failure : null,
+		isBusy: isRequesting || snapshot.phase === "finishing",
+		isRequesting,
+		start
+	};
+}
+function MicrophonePrompt({ isRequesting }) {
+	return /* @__PURE__ */ jsx("p", {
+		"aria-live": "polite",
+		className: "dt-meta",
+		children: isRequesting ? "Allow the microphone in your browser to start." : ""
+	});
+}
+function StartSession({ onStarted, onWriteNote }) {
+	const { account } = useSessionWorkspace();
+	const { failure, isBusy, isRequesting, start } = useRecorderStart(onStarted);
+	const startBlank = () => start({});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(SessionDisclosure, { accountKey: account.key }),
+		/* @__PURE__ */ jsx(MicrophonePrompt, { isRequesting }),
+		failure ? /* @__PURE__ */ jsx(StartProblem, {
+			failure,
+			onRetry: startBlank,
+			onWriteNote
+		}) : /* @__PURE__ */ jsx(StartActions, {
+			isBusy,
+			onStart: startBlank,
+			onWriteNote
+		})
+	] });
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/use-proposal-actions.ts
+const NOTICE_NEED_LENGTH = 60;
+const DECISION_NOTICE = {
+	dismissed: "Dismissed",
+	kept: "Confirmed",
+	later: "Saved for later",
+	pending: "Back to undecided"
+};
+function quotedNeed(need) {
+	return `“${need.length > NOTICE_NEED_LENGTH ? `${need.slice(0, 59)}…` : need}”`;
+}
+function useProposalSave(review) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	return async (failureLabel, request) => {
+		const proposal = await run(failureLabel, () => request(api));
+		if (proposal) review.patch((detail) => withProposal(detail, proposal));
+		return proposal;
+	};
+}
+function decideWithUndo(save) {
+	const restore = async (proposalId, decision) => {
+		if (await save("The decision was not undone", (client) => client.decideProposal({
+			decision,
+			proposalId
+		}))) announce("Decision undone");
+	};
+	return async (proposal, decision) => {
+		const previous = proposal.decision;
+		if (await save("The decision was not saved", (client) => client.decideProposal({
+			decision,
+			proposalId: proposal.id
+		}))) announce(`${DECISION_NOTICE[decision]} ${quotedNeed(proposal.need)}`, {
+			label: "Undo",
+			run: () => restore(proposal.id, previous)
+		});
+	};
+}
+function useProposalActions(review) {
+	const save = useProposalSave(review);
+	return {
+		clarify: (proposal, text) => save("The precision was not sent", (client) => client.clarifyProposal({
+			expectedRevision: proposal.revision,
+			proposalId: proposal.id,
+			text
+		})),
+		decide: decideWithUndo(save),
+		merge: async (targetId, sourceIds) => {
+			if (await save("The intentions were not merged", (client) => client.mergeProposals({
+				sourceIds,
+				targetId
+			}))) review.reload();
+		},
+		save,
+		separate: (proposalId) => save("The suggestion was not cleared", (client) => client.separateProposal(proposalId)),
+		verify: (proposalId, { note, status }) => save("The check was not saved", (client) => client.verifyProposal({
+			note: note || void 0,
+			proposalId,
+			status
+		}))
+	};
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/delete-intention.tsx
+const DELETE_INTENTION_COPY = "Delete this intention? What later sessions added to it is deleted too, along with Reflet's copies of the briefs that included it. Briefs already copied or exported can't be recalled.";
+function DeleteConfirmation$1({ context, onCancel, proposal }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const remove = async () => {
+		if (await run("The intention was not deleted", () => api.deleteProposal(proposal.id)) !== null) {
+			context.review.patch((detail) => ({
+				...detail,
+				proposals: detail.proposals.filter((item) => item.id !== proposal.id)
+			}));
+			announce(`Deleted ${quotedNeed(proposal.need)}`);
+		}
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsx("p", { children: DELETE_INTENTION_COPY }), /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				"data-variant": "danger",
+				onClick: remove,
+				type: "button",
+				children: "Delete"
+			}), /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: onCancel,
+				type: "button",
+				children: "Cancel"
+			})]
+		})]
+	});
+}
+function DeleteIntention({ context, proposal }) {
+	const [isConfirming, setIsConfirming] = useState(false);
+	const [hasCancelled, setHasCancelled] = useState(false);
+	const buttonRef = useFocusWhen(hasCancelled && !isConfirming);
+	if (isConfirming) return /* @__PURE__ */ jsx(DeleteConfirmation$1, {
+		context,
+		onCancel: () => {
+			setIsConfirming(false);
+			setHasCancelled(true);
+		},
+		proposal
+	});
+	return /* @__PURE__ */ jsx("div", {
+		className: "dt-actions",
+		children: /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			"data-variant": "danger",
+			onClick: () => {
+				setIsConfirming(true);
+				setHasCancelled(false);
+			},
+			ref: buttonRef,
+			type: "button",
+			children: "Delete intention"
+		})
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/proposal-details.tsx
+function ListSection({ items, title }) {
+	if (items.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
+		className: "dt-ses-label",
+		children: title
+	}), /* @__PURE__ */ jsx("ul", {
+		className: "dt-ses-list",
+		children: items.map((item) => /* @__PURE__ */ jsx("li", { children: item }, item))
+	})] });
+}
+function RefinementState({ onRetry, proposal }) {
+	const { refinement } = proposal;
+	if (refinement?.state === "running") return /* @__PURE__ */ jsx("p", {
+		className: "dt-status",
+		children: "Refining…"
+	});
+	if (refinement?.state === "outdated") return /* @__PURE__ */ jsx("p", {
+		className: "dt-meta",
+		children: "The intention changed while it was being refined. Add your precision again."
+	});
+	if (refinement?.state !== "failed") return null;
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-actions",
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: "dt-error",
+			children: ["Refining failed: ", refinement.error ?? "Unknown error."]
+		}), /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: onRetry,
+			type: "button",
+			children: "Retry"
+		})]
+	});
+}
+function ClarifyBox({ context, proposal }) {
+	const [text, setText] = useState("");
+	const isRefining = proposal.refinement?.state === "running";
+	const lastClarification = proposal.clarifications.at(-1)?.text;
+	const send = async (value) => {
+		if (await context.actions.clarify(proposal, value)) setText("");
+	};
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-form",
+		children: [
+			proposal.question && /* @__PURE__ */ jsx("p", {
+				className: "dt-note-text",
+				children: proposal.question
+			}),
+			/* @__PURE__ */ jsx("textarea", {
+				"aria-label": proposal.question ? "Your answer" : "Add a precision…",
+				className: "dt-field",
+				disabled: isRefining,
+				maxLength: 1e3,
+				onChange: (event) => setText(event.target.value),
+				placeholder: "Add a precision…",
+				rows: 2,
+				value: text
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "dt-actions",
+				children: /* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					disabled: isRefining || text.trim() === "",
+					onClick: () => send(text.trim()),
+					type: "button",
+					children: "Update intention"
+				})
+			}),
+			/* @__PURE__ */ jsx(RefinementState, {
+				onRetry: () => lastClarification && send(lastClarification),
+				proposal
+			})
+		]
+	});
+}
+function Sources({ context, proposal }) {
+	const segmentIds = new Set(proposal.segmentIds);
+	const evidenceIds = new Set(proposal.evidenceIds);
+	const segments = context.detail.segments.filter((segment) => segmentIds.has(segment.id));
+	const evidence = context.detail.evidence.filter((item) => evidenceIds.has(item.id));
+	if (segments.length + evidence.length === 0) return null;
+	return /* @__PURE__ */ jsxs("section", { children: [
+		/* @__PURE__ */ jsx("h4", {
+			className: "dt-ses-label",
+			children: "Sources"
+		}),
+		segments.map((segment) => /* @__PURE__ */ jsxs("button", {
+			className: "dt-ses-quote",
+			onClick: (event) => context.navigation.onShowMoment(segment.id, event.currentTarget),
+			type: "button",
+			children: [/* @__PURE__ */ jsx("span", {
+				className: "dt-ses-time",
+				children: formatClock(segment.startMs)
+			}), ` “${segment.text}”`]
+		}, segment.id)),
+		/* @__PURE__ */ jsx("div", {
+			className: "dt-ses-thumbs",
+			children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceThumb, { evidence: item }, item.id))
+		})
+	] });
+}
+function ProposalDetails({ context, proposal }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h4", {
+			className: "dt-ses-label",
+			children: "What you said or showed — not verified"
+		}), /* @__PURE__ */ jsx("p", {
+			className: "dt-note-text",
+			children: proposal.observed
+		})] }),
+		/* @__PURE__ */ jsx(ListSection, {
+			items: proposal.setAside,
+			title: "Set aside"
+		}),
+		context.canEdit && /* @__PURE__ */ jsx(ClarifyBox, {
+			context,
+			proposal
+		}),
+		/* @__PURE__ */ jsx(Sources, {
+			context,
+			proposal
+		}),
+		/* @__PURE__ */ jsx(IntentionHistory, {
+			context,
+			intentionId: proposal.id
+		}),
+		context.canEdit && /* @__PURE__ */ jsx(DeleteIntention, {
+			context,
+			proposal
+		})
+	] });
+}
+//#endregion
+//#region src/sessions/ui/review/continuation/continue-panel.tsx
+const MAX_TITLE_NEED_CHARS = 80;
+function continuationOf(proposal) {
+	return {
+		continues: {
+			intentionId: proposal.id,
+			revision: proposal.revision
+		},
+		title: continueTitle(proposal.need)
+	};
+}
+function continueTitle(need) {
+	return `Continue: ${need.length > MAX_TITLE_NEED_CHARS ? `${need.slice(0, 79)}…` : need}`;
+}
+function IntentionRecap({ proposal }) {
+	const stillOpen = proposal.question ? [...proposal.unknowns, proposal.question] : proposal.unknowns;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("p", {
+			className: "dt-note-text",
+			children: proposal.need
+		}),
+		proposal.response && /* @__PURE__ */ jsxs("section", { children: [/* @__PURE__ */ jsx("h5", {
+			className: "dt-ses-label",
+			children: "Considered response"
+		}), /* @__PURE__ */ jsx("p", {
+			className: "dt-note-text",
+			children: proposal.response
+		})] }),
+		/* @__PURE__ */ jsx(ListSection, {
+			items: stillOpen,
+			title: "Still open"
+		}),
+		/* @__PURE__ */ jsx("p", {
+			className: "dt-meta",
+			children: "Speak to refine the need or check the result. Nothing is sent to an agent."
+		})
+	] });
+}
+function ContinuePanel({ onCancel, onStarted, proposal }) {
+	const headingId = useId();
+	const headingRef = useFocusWhen(true);
+	const { failure, isBusy, isRequesting, start } = useRecorderStart(onStarted);
+	const startContinuation = () => start(continuationOf(proposal));
+	return /* @__PURE__ */ jsxs("section", {
+		"aria-labelledby": headingId,
+		className: "dt-ses-banner",
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: "dt-ses-subhead",
+				id: headingId,
+				ref: headingRef,
+				tabIndex: -1,
+				children: "Continue this intention"
+			}),
+			/* @__PURE__ */ jsx(IntentionRecap, { proposal }),
+			/* @__PURE__ */ jsx(MicrophonePrompt, { isRequesting }),
+			failure && /* @__PURE__ */ jsx(StartProblem, {
+				failure,
+				onRetry: startContinuation
+			}),
+			/* @__PURE__ */ jsxs("div", {
+				className: "dt-actions",
+				children: [!failure && /* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					"data-variant": "primary",
+					disabled: isBusy,
+					onClick: startContinuation,
+					type: "button",
+					children: "Start session"
+				}), /* @__PURE__ */ jsx("button", {
+					className: "dt-btn",
+					onClick: onCancel,
+					type: "button",
+					children: "Cancel"
+				})]
+			})
+		]
+	});
+}
+function ContinueIntention({ context, proposal }) {
+	const [isOpen, setIsOpen] = useState(false);
+	const [hasClosed, setHasClosed] = useState(false);
+	const buttonRef = useFocusWhen(hasClosed && !isOpen);
+	if (!(context.canEdit && proposal.decision !== "dismissed" && proposal.mergedIntoId === null && proposal.attachment === null)) return null;
+	if (isOpen) return /* @__PURE__ */ jsx(ContinuePanel, {
+		onCancel: () => {
+			setIsOpen(false);
+			setHasClosed(true);
+		},
+		onStarted: context.navigation.onStarted,
+		proposal
+	});
+	return /* @__PURE__ */ jsx("div", {
+		className: "dt-actions",
+		children: /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: () => {
+				setIsOpen(true);
+				setHasClosed(false);
+			},
+			ref: buttonRef,
+			type: "button",
+			children: "Continue this intention"
+		})
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/moment/intention-source.tsx
+function IntentionSource({ context, proposal }) {
+	const { segments } = context.detail;
+	const firstSegmentId = proposal.segmentIds.find((segmentId) => segments.some((segment) => segment.id === segmentId));
+	const segment = segments.find((item) => item.id === firstSegmentId);
+	if (!segment) return null;
+	const [firstContext] = segment.context;
+	const range = `${formatClock(segment.startMs)}–${formatClock(segment.endMs)}`;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-block",
+		children: [
+			/* @__PURE__ */ jsxs("p", {
+				className: "dt-ses-source",
+				children: [
+					/* @__PURE__ */ jsx("span", {
+						className: "dt-ses-time",
+						children: range
+					}),
+					" “",
+					segment.text,
+					"”"
+				]
+			}),
+			firstContext && /* @__PURE__ */ jsx("p", {
+				className: "dt-meta",
+				children: contextLine(firstContext)
+			}),
+			/* @__PURE__ */ jsx("button", {
+				className: "dt-ses-link",
+				onClick: (event) => context.navigation.onShowMoment(segment.id, event.currentTarget),
+				type: "button",
+				children: "Show context"
+			})
+		]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/intention-suggestion.tsx
+function useAttach(context, proposal) {
+	const [isBusy, setIsBusy] = useState(false);
+	const attach = async (suggestion, shareWithTeam) => {
+		setIsBusy(true);
+		try {
+			if (await context.actions.save("The session was not added to the intention", (api) => api.attachToIntention({
+				intentionId: suggestion.intentionId,
+				proposalId: proposal.id,
+				...shareWithTeam ? { shareWithTeam } : {}
+			}))) announce(`Added to ${quotedNeed(suggestion.need)}`);
+		} finally {
+			setIsBusy(false);
+		}
+	};
+	const keepSeparate = () => context.actions.save("The suggestion was not cleared", (api) => api.keepSeparate(proposal.id));
+	return {
+		attach,
+		isBusy,
+		keepSeparate
+	};
+}
+function SuggestionChoices({ canEdit, handlers, suggestion }) {
+	return /* @__PURE__ */ jsxs("div", {
+		className: "dt-ses-banner",
+		children: [/* @__PURE__ */ jsxs("p", { children: [
+			"Might belong to “",
+			suggestion.need,
+			"” (from “",
+			suggestion.sessionTitle,
+			"”):",
+			" ",
+			suggestion.reason
+		] }), canEdit && /* @__PURE__ */ jsxs("div", {
+			className: "dt-actions",
+			children: [/* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				disabled: handlers.isBusy,
+				onClick: handlers.onAdd,
+				type: "button",
+				children: "Add to this intention"
+			}), /* @__PURE__ */ jsx("button", {
+				className: "dt-btn",
+				onClick: handlers.onKeepSeparate,
+				type: "button",
+				children: "Keep separate"
+			})]
+		})]
+	});
+}
+function IntentionSuggestionBanner({ context, proposal }) {
+	const [isPreviewing, setIsPreviewing] = useState(false);
+	const { attach, isBusy, keepSeparate } = useAttach(context, proposal);
+	const suggestion = proposal.intentionSuggestion;
+	if (!suggestion) return null;
+	if (isPreviewing) return /* @__PURE__ */ jsx(SharePreview, {
+		confirmation: {
+			isBusy,
+			label: "Share and add",
+			onCancel: () => setIsPreviewing(false),
+			onConfirm: () => attach(suggestion, true)
+		},
+		detail: context.detail,
+		extracts: proposal
+	});
+	return /* @__PURE__ */ jsx(SuggestionChoices, {
+		canEdit: context.canEdit,
+		handlers: {
+			isBusy,
+			onAdd: () => suggestion.needsShareConsent ? setIsPreviewing(true) : attach(suggestion, false),
+			onKeepSeparate: keepSeparate
+		},
+		suggestion
+	});
+}
+function AttachedIntentionRow({ attachment, context }) {
+	const { api } = useSessionWorkspace();
+	const run = useSessionAction();
+	const undo = async () => {
+		if (await run("The session was not separated", () => api.detachContribution(attachment.contributionId))) {
+			announce(`Separated from ${quotedNeed(attachment.need)}`);
+			context.review.reload();
+		}
+	};
+	return /* @__PURE__ */ jsxs("article", {
+		className: "dt-card dt-ses-attached",
+		children: [/* @__PURE__ */ jsxs("p", {
+			className: "dt-meta",
+			children: [
+				"Added to intention “",
+				attachment.need,
+				"”"
+			]
+		}), context.canEdit && /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: undo,
+			type: "button",
+			children: "Undo"
+		})]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/verification.tsx
+const OUTCOME_LABELS = {
+	needs_work: "Needs more work",
+	works: "Works"
+};
+function Verification({ context, proposal }) {
+	const [note, setNote] = useState(proposal.verification?.note ?? "");
+	if (proposal.handedOffRevision === null) return null;
+	const { verification } = proposal;
+	return /* @__PURE__ */ jsxs("fieldset", {
+		className: "dt-ses-verify",
+		children: [
+			/* @__PURE__ */ jsx("legend", {
+				className: "dt-ses-label",
+				children: "Did the change work?"
+			}),
+			verification && /* @__PURE__ */ jsxs("p", {
+				className: "dt-meta",
+				children: [
+					"Checked: ",
+					OUTCOME_LABELS[verification.status],
+					verification.note ? ` · ${verification.note}` : ""
+				]
+			}),
+			/* @__PURE__ */ jsx("input", {
+				"aria-label": "Note about the change (optional)",
+				className: "dt-field",
+				maxLength: 1e3,
+				onChange: (event) => setNote(event.target.value),
+				placeholder: "Note (optional)",
+				value: note
+			}),
+			/* @__PURE__ */ jsx("div", {
+				className: "dt-actions",
+				children: ["works", "needs_work"].map((status) => /* @__PURE__ */ jsx("button", {
+					"aria-pressed": verification?.status === status,
+					className: "dt-btn",
+					onClick: () => context.actions.verify(proposal.id, {
+						note: note.trim(),
+						status
+					}),
+					type: "button",
+					children: OUTCOME_LABELS[status]
+				}, status))
+			})
+		]
+	});
+}
+//#endregion
+//#region src/sessions/ui/review/proposals/proposal-card.tsx
+const DECISION_CHIPS = {
+	dismissed: "Dismissed",
+	kept: "Confirmed",
+	later: "Later"
+};
+const FORMULATION_CHIPS = {
+	ai: "AI wording",
+	human: "Your wording"
+};
+const DECISION_BUTTONS = [
+	{
+		decision: "kept",
+		label: "Confirm"
+	},
+	{
+		decision: "later",
+		label: "Later"
+	},
+	{
+		decision: "dismissed",
+		label: "Dismiss"
+	}
+];
+function ProposalChips({ proposal }) {
+	const decisionChip = DECISION_CHIPS[proposal.decision];
+	const { handedOffRevision } = proposal;
+	let handoffChip = null;
+	if (handedOffRevision !== null) handoffChip = proposal.revision > handedOffRevision ? "Changed since handoff" : `Handed off rev ${handedOffRevision}`;
 	return /* @__PURE__ */ jsxs("div", {
 		className: "dt-ses-chips",
 		children: [
+			decisionChip && /* @__PURE__ */ jsx("span", {
+				className: "dt-chip",
+				children: decisionChip
+			}),
+			/* @__PURE__ */ jsx("span", {
+				className: "dt-chip",
+				children: FORMULATION_CHIPS[proposal.formulation]
+			}),
 			proposal.certainty === "uncertain" && /* @__PURE__ */ jsx("span", {
 				className: "dt-chip",
 				children: "Unclear"
@@ -4490,11 +7359,7 @@ function ProposalChips({ proposal }) {
 			proposal.needsReview && /* @__PURE__ */ jsx("span", {
 				className: "dt-chip",
 				"data-tone": "accent",
-				children: "Needs review"
-			}),
-			decisionChip && /* @__PURE__ */ jsx("span", {
-				className: "dt-chip",
-				children: decisionChip
+				children: "To re-examine"
 			}),
 			handoffChip && /* @__PURE__ */ jsx("span", {
 				className: "dt-chip",
@@ -4585,34 +7450,94 @@ function DetailsDisclosure({ context, disclosure, proposal }) {
 		})
 	})] });
 }
-function ProposalCard({ context, proposal }) {
-	const disclosure = useDisclosure();
+function ToCheck({ proposal }) {
+	const items = proposal.question ? [...proposal.unknowns, proposal.question] : proposal.unknowns;
+	return /* @__PURE__ */ jsx(ListSection, {
+		items,
+		title: "To check"
+	});
+}
+function ResponseBlock({ context, proposal }) {
 	const [isEditing, setIsEditing] = useState(false);
-	if (isEditing) return /* @__PURE__ */ jsx("article", {
-		className: "dt-card",
-		children: /* @__PURE__ */ jsx(ProposalEditor, {
-			onDone: () => setIsEditing(false),
-			proposal,
-			review: context.review
-		}, proposal.revision)
+	if (isEditing) return /* @__PURE__ */ jsx(ResponseEditor, {
+		onDone: () => setIsEditing(false),
+		proposal,
+		review: context.review
+	});
+	if (!(proposal.response || context.canEdit)) return null;
+	return /* @__PURE__ */ jsxs("section", {
+		className: "dt-ses-block",
+		children: [
+			/* @__PURE__ */ jsx("h4", {
+				className: "dt-ses-label",
+				children: "Considered response"
+			}),
+			/* @__PURE__ */ jsx("p", {
+				className: proposal.response ? "dt-note-text" : "dt-meta",
+				children: proposal.response ?? "No considered response yet."
+			}),
+			context.canEdit && /* @__PURE__ */ jsx("button", {
+				className: "dt-ses-link",
+				onClick: () => setIsEditing(true),
+				type: "button",
+				children: "Edit response"
+			})
+		]
 	});
+}
+function IntentionBody({ context, disclosure, proposal }) {
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx("p", {
+			className: "dt-ses-label",
+			children: "Intention"
+		}),
+		/* @__PURE__ */ jsx("p", {
+			className: "dt-ses-need",
+			"data-expanded": disclosure.isExpanded,
+			children: proposal.need
+		}),
+		/* @__PURE__ */ jsx(ProposalChips, { proposal }),
+		/* @__PURE__ */ jsx(IntentionSource, {
+			context,
+			proposal
+		}),
+		/* @__PURE__ */ jsx(ResponseBlock, {
+			context,
+			proposal
+		}),
+		/* @__PURE__ */ jsx(ToCheck, { proposal })
+	] });
+}
+function IntentionCard({ context, onEdit, proposal }) {
+	const disclosure = useDisclosure();
+	const cardRef = useFocusWhen(context.focusIntentionId === proposal.id);
 	return /* @__PURE__ */ jsxs("article", {
+		"aria-label": `Intention: ${proposal.need}`,
 		className: "dt-card",
 		"data-decision": proposal.decision,
+		ref: cardRef,
+		tabIndex: -1,
 		children: [
-			/* @__PURE__ */ jsx("p", {
-				className: "dt-ses-need",
-				"data-expanded": disclosure.isExpanded,
-				children: proposal.need
+			/* @__PURE__ */ jsx(IntentionBody, {
+				context,
+				disclosure,
+				proposal
 			}),
-			/* @__PURE__ */ jsx(ProposalChips, { proposal }),
 			/* @__PURE__ */ jsx(MergeSuggestion, {
 				context,
 				proposal
 			}),
+			/* @__PURE__ */ jsx(IntentionSuggestionBanner, {
+				context,
+				proposal
+			}),
 			context.canEdit && /* @__PURE__ */ jsx(DecisionButtons, {
 				context,
-				onEdit: () => setIsEditing(true),
+				onEdit,
+				proposal
+			}),
+			/* @__PURE__ */ jsx(ContinueIntention, {
+				context,
 				proposal
 			}),
 			/* @__PURE__ */ jsx(DetailsDisclosure, {
@@ -4627,16 +7552,36 @@ function ProposalCard({ context, proposal }) {
 		]
 	});
 }
+function ProposalCard({ context, proposal }) {
+	const [isEditing, setIsEditing] = useState(false);
+	if (proposal.attachment) return /* @__PURE__ */ jsx(AttachedIntentionRow, {
+		attachment: proposal.attachment,
+		context
+	});
+	if (isEditing) return /* @__PURE__ */ jsx("article", {
+		className: "dt-card",
+		children: /* @__PURE__ */ jsx(ProposalEditor, {
+			onDone: () => setIsEditing(false),
+			proposal,
+			review: context.review
+		}, proposal.revision)
+	});
+	return /* @__PURE__ */ jsx(IntentionCard, {
+		context,
+		onEdit: () => setIsEditing(true),
+		proposal
+	});
+}
 //#endregion
 //#region src/sessions/ui/review/proposals/proposals-tab.tsx
 function emptyCopy(detail) {
 	const { session } = detail;
-	if (session.collection !== "ended") return "Proposals appear here once the recording has uploaded and Reflet has read it.";
+	if (session.collection !== "ended") return "Intentions appear here once the recording has uploaded and Reflet has read it.";
 	if (detail.segments.length === 0 && detail.marks.length === 0) return "Nothing was said or marked in this session.";
-	if (isAnalysisBusy(session)) return "Proposals appear here once Reflet has read the session.";
-	if (session.analysis.state === "failed") return "The transcript is kept. Read it, or write the proposal yourself.";
-	if (session.analysis.state === "succeeded") return "No request stood out in this session. Read the transcript or write the proposal yourself.";
-	return "Proposals appear here once the session is analyzed.";
+	if (isAnalysisBusy(session)) return "Intentions appear here once Reflet has read the session.";
+	if (session.analysis.state === "failed") return "The transcript is kept. Read it, or write the intention yourself.";
+	if (session.analysis.state === "succeeded") return "No request stood out in this session. Read the transcript or write the intention yourself.";
+	return "Intentions appear here once the session is analyzed.";
 }
 function useAddProposal(context, onDone) {
 	const [need, setNeed] = useState("");
@@ -4647,7 +7592,7 @@ function useAddProposal(context, onDone) {
 	const add = async () => {
 		setIsSaving(true);
 		try {
-			if (await context.actions.save("The proposal was not added", (api) => api.createProposal({
+			if (await context.actions.save("The intention was not added", (api) => api.createProposal({
 				clientKey,
 				need: need.trim(),
 				observed: observed.trim() || void 0,
@@ -4692,7 +7637,7 @@ function AddProposalForm({ context, onDone }) {
 			/* @__PURE__ */ jsx(FormActions, {
 				isSubmitDisabled: isSaving || need.trim() === "",
 				onCancel: onDone,
-				submitLabel: "Add proposal"
+				submitLabel: "Add intention"
 			})
 		]
 	});
@@ -4700,8 +7645,13 @@ function AddProposalForm({ context, onDone }) {
 function ProposalsTab({ context }) {
 	const [isAdding, setIsAdding] = useState(false);
 	const proposals = context.detail.proposals.filter((proposal) => proposal.mergedIntoId === null);
+	const { continuation } = context.detail;
 	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		proposals.length === 0 && /* @__PURE__ */ jsx("p", {
+		continuation && /* @__PURE__ */ jsx(UpdateCard, {
+			context,
+			continuation
+		}),
+		proposals.length === 0 && !continuation && /* @__PURE__ */ jsx("p", {
 			className: "dt-empty",
 			children: emptyCopy(context.detail)
 		}),
@@ -4718,14 +7668,14 @@ function ProposalsTab({ context }) {
 				className: "dt-btn",
 				onClick: () => setIsAdding(true),
 				type: "button",
-				children: "Add a proposal"
+				children: "Add an intention"
 			})
 		}))
 	] });
 }
 //#endregion
 //#region src/sessions/ui/review/review-header.tsx
-const DELETE_COPY = "Delete this session? Its recordings, transcript and proposals are removed. Briefs you already copied or exported can't be recalled.";
+const DELETE_COPY = "Delete this session? Its recordings, transcript and intentions are removed, including what later sessions added to those intentions. Briefs you already copied or exported can't be recalled.";
 function useSessionUpdate(review, sessionId) {
 	const { api } = useSessionWorkspace();
 	const run = useSessionAction();
@@ -5084,60 +8034,23 @@ function AttachLink({ detail, onDone, review }) {
 	});
 }
 //#endregion
-//#region src/sessions/ui/review/transcript/remove-evidence.tsx
-const REMOVE_COPY = "Remove this screenshot? The image is deleted for good. Briefs you already copied or exported can't be recalled.";
-function RemoveConfirmation({ evidence, onCancel, review }) {
-	const { api } = useSessionWorkspace();
-	const run = useSessionAction();
-	const cancelRef = useRef(null);
-	useEffect(() => {
-		cancelRef.current?.focus();
-	}, []);
-	const remove = async () => {
-		const removed = await run("The screenshot was not removed", () => api.removeEvidence(evidence.id));
-		if (removed !== null) {
-			review.patch((detail) => withEvidence(detail, removed));
-			announce("Screenshot removed");
-		}
-	};
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-banner",
-		children: [/* @__PURE__ */ jsx("p", { children: REMOVE_COPY }), /* @__PURE__ */ jsxs("div", {
-			className: "dt-actions",
-			children: [/* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				"data-variant": "danger",
-				onClick: remove,
-				type: "button",
-				children: "Remove"
-			}), /* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				onClick: onCancel,
-				ref: cancelRef,
-				type: "button",
-				children: "Cancel"
-			})]
+//#region src/sessions/ui/review/transcript/evidence-tab.tsx
+const isViewable = (evidence) => evidence.status === "available" && Boolean(evidence.image?.url);
+function MissingEvidenceItem({ caption, evidence, isJustRemoved }) {
+	const cardRef = useFocusWhen(isJustRemoved);
+	return /* @__PURE__ */ jsxs("li", {
+		className: "dt-card",
+		ref: cardRef,
+		tabIndex: isJustRemoved ? -1 : void 0,
+		children: [/* @__PURE__ */ jsx("p", {
+			className: "dt-meta",
+			children: caption
+		}), /* @__PURE__ */ jsxs("p", {
+			className: "dt-meta",
+			children: ["Screenshot missing: ", evidence.missingReason ?? "not captured."]
 		})]
 	});
 }
-function RemoveEvidence({ evidence, review }) {
-	const [isConfirming, setIsConfirming] = useState(false);
-	if (isConfirming) return /* @__PURE__ */ jsx(RemoveConfirmation, {
-		evidence,
-		onCancel: () => setIsConfirming(false),
-		review
-	});
-	return /* @__PURE__ */ jsx("button", {
-		"aria-label": `Remove screenshot at ${formatClock(evidence.atMs)}`,
-		className: "dt-ses-link",
-		onClick: () => setIsConfirming(true),
-		type: "button",
-		children: "Remove"
-	});
-}
-//#endregion
-//#region src/sessions/ui/review/transcript/evidence-tab.tsx
-const isViewable = (evidence) => evidence.status === "available" && Boolean(evidence.image?.url);
 function LinkEvidenceItem({ link }) {
 	return /* @__PURE__ */ jsxs("li", {
 		className: "dt-card",
@@ -5160,18 +8073,23 @@ function LinkEvidenceItem({ link }) {
 		]
 	});
 }
-function EvidenceItem({ evidence, onEnlarge, removal }) {
+function MomentLink({ atMs, onShowMoment }) {
+	if (!onShowMoment) return null;
+	return /* @__PURE__ */ jsx("button", {
+		"aria-label": `Show the moment at ${formatClock(atMs)}`,
+		className: "dt-ses-link",
+		onClick: (event) => onShowMoment(event.currentTarget),
+		type: "button",
+		children: "Show moment"
+	});
+}
+function EvidenceItem({ evidence, openers, removal }) {
 	const caption = `${formatClock(evidence.atMs)} · ${evidenceCaption(evidence)}`;
 	if (evidence.link) return /* @__PURE__ */ jsx(LinkEvidenceItem, { link: evidence.link });
-	if (!isViewable(evidence)) return /* @__PURE__ */ jsxs("li", {
-		className: "dt-card",
-		children: [/* @__PURE__ */ jsx("p", {
-			className: "dt-meta",
-			children: caption
-		}), /* @__PURE__ */ jsxs("p", {
-			className: "dt-meta",
-			children: ["Screenshot missing: ", evidence.missingReason ?? "not captured."]
-		})]
+	if (!isViewable(evidence)) return /* @__PURE__ */ jsx(MissingEvidenceItem, {
+		caption,
+		evidence,
+		isJustRemoved: evidence.id === removal.removedId
 	});
 	return /* @__PURE__ */ jsxs("li", {
 		className: "dt-card",
@@ -5179,7 +8097,7 @@ function EvidenceItem({ evidence, onEnlarge, removal }) {
 			/* @__PURE__ */ jsx("button", {
 				"aria-label": `Enlarge: ${caption}`,
 				className: "dt-ses-shot-btn",
-				onClick: onEnlarge,
+				onClick: openers.onEnlarge,
 				type: "button",
 				children: /* @__PURE__ */ jsx(EvidenceThumb, { evidence })
 			}),
@@ -5191,9 +8109,13 @@ function EvidenceItem({ evidence, onEnlarge, removal }) {
 				className: "dt-note-text",
 				children: evidence.note
 			}),
+			/* @__PURE__ */ jsx(MomentLink, {
+				atMs: evidence.atMs,
+				onShowMoment: openers.onShowMoment
+			}),
 			removal.canRemove && /* @__PURE__ */ jsx(RemoveEvidence, {
 				evidence,
-				review: removal.review
+				removal
 			})
 		]
 	});
@@ -5220,11 +8142,17 @@ function EnlargedEvidence({ evidence, onBack, removal }) {
 		}),
 		removal.canRemove && /* @__PURE__ */ jsx(RemoveEvidence, {
 			evidence,
-			review: removal.review
+			removal
 		})
 	] });
 }
-function EvidenceList({ evidence, onEnlarge, removal }) {
+function EvidenceList({ detail, openers, removal }) {
+	const { onEnlarge, onShowMoment } = openers;
+	const { evidence } = detail;
+	const momentOpener = (atMs) => {
+		const segmentId = nearestSegmentId(detail.segments, atMs);
+		return segmentId ? (opener) => onShowMoment(segmentId, opener) : null;
+	};
 	return /* @__PURE__ */ jsxs(Fragment, { children: [evidence.length === 0 && /* @__PURE__ */ jsx("p", {
 		className: "dt-empty",
 		children: "No screenshots or links in this session."
@@ -5232,352 +8160,86 @@ function EvidenceList({ evidence, onEnlarge, removal }) {
 		className: "dt-ses-rows",
 		children: evidence.map((item) => /* @__PURE__ */ jsx(EvidenceItem, {
 			evidence: item,
-			onEnlarge: () => onEnlarge(item.id),
+			openers: {
+				onEnlarge: () => onEnlarge(item.id),
+				onShowMoment: momentOpener(item.atMs)
+			},
 			removal
 		}, item.id))
-	})] });
-}
-function EvidenceTab({ detail, review }) {
-	const [enlargedId, setEnlargedId] = useState(null);
-	const [isAttaching, setIsAttaching] = useState(false);
-	const enlarged = detail.evidence.find((item) => item.id === enlargedId && isViewable(item));
-	const removal = {
-		canRemove: detail.session.canEdit,
-		review
-	};
-	if (enlarged) return /* @__PURE__ */ jsx(EnlargedEvidence, {
-		evidence: enlarged,
-		onBack: () => setEnlargedId(null),
-		removal
-	});
-	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(EvidenceList, {
-		evidence: detail.evidence,
-		onEnlarge: setEnlargedId,
-		removal
-	}), detail.session.canEdit && (isAttaching ? /* @__PURE__ */ jsx(AttachLink, {
-		detail,
-		onDone: () => setIsAttaching(false),
-		review
-	}) : /* @__PURE__ */ jsx("div", {
-		className: "dt-actions",
-		children: /* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			onClick: () => setIsAttaching(true),
-			type: "button",
-			children: "Attach a link"
-		})
-	}))] });
-}
-//#endregion
-//#region src/sessions/ui/review/transcript/segment-row.tsx
-function SaveCancelActions({ isSaveDisabled, onCancel, onSave }) {
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-actions",
-		children: [/* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			"data-variant": "primary",
-			disabled: isSaveDisabled,
-			onClick: onSave,
-			type: "button",
-			children: "Save"
-		}), /* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			onClick: onCancel,
-			type: "button",
-			children: "Cancel"
-		})]
-	});
-}
-function SegmentEditor({ onDone, review, segment }) {
-	const { api } = useSessionWorkspace();
-	const { isSaving, problem, save } = useGuardedSave();
-	const [text, setText] = useState(segment.text);
-	const submit = () => save(async () => {
-		const saved = await api.correctSegment({
-			expectedRevision: segment.revision,
-			segmentId: segment.id,
-			text: text.trim()
-		});
-		review.patch((detail) => withSegment(detail, saved));
-		review.reload();
-		onDone();
-	});
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-form",
-		children: [
-			/* @__PURE__ */ jsx("textarea", {
-				"aria-label": `Passage at ${formatClock(segment.startMs)}`,
-				className: "dt-field",
-				maxLength: 5e3,
-				onChange: (event) => setText(event.target.value),
-				rows: 3,
-				value: text
-			}),
-			problem && /* @__PURE__ */ jsx(SaveProblemMessage, {
-				onReload: review.reload,
-				problem
-			}),
-			/* @__PURE__ */ jsx(SaveCancelActions, {
-				isSaveDisabled: isSaving || text.trim() === "",
-				onCancel: onDone,
-				onSave: submit
-			})
-		]
-	});
-}
-function SegmentBody({ onType, review, segment }) {
-	const { api } = useSessionWorkspace();
-	const run = useSessionAction();
-	const { state } = segment.transcription;
-	const retry = async () => {
-		const pending = await run("The transcription did not restart", () => api.retrySegment(segment.id));
-		if (pending) review.patch((detail) => withSegment(detail, pending));
-	};
-	if (state === "pending" || state === "running") return /* @__PURE__ */ jsx("p", {
-		className: "dt-status",
-		children: "Transcribing…"
-	});
-	if (state === "failed" || state === "expired") return /* @__PURE__ */ jsxs("div", {
-		className: "dt-actions",
-		children: [
-			/* @__PURE__ */ jsx("p", {
-				className: "dt-error",
-				children: state === "failed" ? "Couldn't transcribe" : "Audio expired — type what you said"
-			}),
-			onType && state === "failed" && segment.hasAudio && /* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				onClick: retry,
-				type: "button",
-				children: "Retry"
-			}),
-			onType && /* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				onClick: onType,
-				type: "button",
-				children: "Type it"
-			})
-		]
-	});
-	if (state === "empty" && segment.text === "") return /* @__PURE__ */ jsx("p", {
-		className: "dt-meta",
-		children: "No speech was heard here."
-	});
-	return /* @__PURE__ */ jsx("p", {
-		className: "dt-note-text",
-		children: segment.text
-	});
-}
-function ContextChips({ segment }) {
-	if (segment.context.length === 0) return null;
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-chips",
-		children: [segment.contextAmbiguous && /* @__PURE__ */ jsx("span", {
-			className: "dt-chip",
-			children: "Unclear which element"
-		}), segment.context.map((item) => /* @__PURE__ */ jsx("span", {
-			className: "dt-chip",
-			children: item.label
-		}, `${item.kind}:${item.atMs}:${item.label}`))]
-	});
-}
-function EditPassageLink({ onEdit, time }) {
-	return /* @__PURE__ */ jsx("button", {
-		"aria-label": `Edit passage at ${time}`,
-		className: "dt-ses-link",
-		onClick: onEdit,
-		type: "button",
-		children: "Edit"
-	});
-}
-function SegmentRow({ canEdit, isFocused, review, segment }) {
-	const [isEditing, setIsEditing] = useState(false);
-	const time = formatClock(segment.startMs);
-	const isSettled = ["done", "empty"].includes(segment.transcription.state);
-	return /* @__PURE__ */ jsxs("li", {
-		className: "dt-ses-seg",
-		ref: isFocused ? (node) => node?.focus({ preventScroll: false }) : void 0,
-		tabIndex: -1,
-		children: [/* @__PURE__ */ jsx("span", {
-			className: "dt-ses-time",
-			children: time
-		}), /* @__PURE__ */ jsxs("div", {
-			className: "dt-ses-seg-body",
-			children: [
-				isEditing ? /* @__PURE__ */ jsx(SegmentEditor, {
-					onDone: () => setIsEditing(false),
-					review,
-					segment
-				}) : /* @__PURE__ */ jsx(SegmentBody, {
-					onType: canEdit ? () => setIsEditing(true) : void 0,
-					review,
-					segment
-				}),
-				/* @__PURE__ */ jsx(ContextChips, { segment }),
-				canEdit && isSettled && !isEditing && /* @__PURE__ */ jsx(EditPassageLink, {
-					onEdit: () => setIsEditing(true),
-					time
-				})
-			]
-		})]
-	});
-}
-//#endregion
-//#region src/sessions/ui/review/transcript/transcript-tab.tsx
-const GAP_LABELS = {
-	hidden: "Tab hidden",
-	interrupted: "Interrupted",
-	limit: "Time limit reached",
-	paused: "Paused"
-};
-function gapLabel(gap) {
-	const label = GAP_LABELS[gap.reason];
-	return gap.endMs === null ? label : `${label} · ${shortDuration(gap.endMs - gap.startMs)}`;
-}
-function markLabel(mark) {
-	const note = mark.note ? ` — ${mark.note}` : "";
-	if (mark.kind === "navigation") return `Went to ${mark.url ?? mark.label}`;
-	return `${mark.kind === "select" ? "Pointed at" : "Marked a moment on"} ${mark.label}${note}`;
-}
-function TimelineNote({ atMs, children }) {
-	return /* @__PURE__ */ jsxs("li", {
-		className: "dt-ses-seg",
-		"data-kind": "note",
-		children: [/* @__PURE__ */ jsx("span", {
-			className: "dt-ses-time",
-			children: formatClock(atMs)
-		}), /* @__PURE__ */ jsx("p", {
-			className: "dt-meta",
-			children
-		})]
-	});
-}
-function buildTimeline(detail) {
-	return [
-		...detail.segments.map((segment) => ({
-			atMs: segment.startMs,
-			key: `s:${segment.id}`,
-			segment
-		})),
-		...detail.session.gaps.map((gap) => ({
-			atMs: gap.startMs,
-			key: `g:${gap.startMs}`,
-			label: gapLabel(gap)
-		})),
-		...detail.marks.map((mark) => ({
-			atMs: mark.atMs,
-			key: `m:${mark.kind}:${mark.atMs}`,
-			label: markLabel(mark)
-		}))
-	].sort((earlier, later) => earlier.atMs - later.atMs);
-}
-function useTypedPassage({ detail, review }) {
-	const { api } = useSessionWorkspace();
-	const run = useSessionAction();
-	const [text, setText] = useState("");
-	const [clientKey, setClientKey] = useState(() => crypto.randomUUID());
-	const atMs = detail.segments.at(-1)?.endMs ?? 0;
-	const add = async () => {
-		const segment = await run("The passage was not added", () => api.addTypedSegment({
-			clientKey,
-			endMs: atMs,
-			sessionId: detail.session.id,
-			startMs: atMs,
-			text: text.trim()
-		}));
-		if (segment) {
-			review.patch((current) => withSegment(current, segment));
-			setText("");
-			setClientKey(crypto.randomUUID());
-		}
-	};
-	return {
-		add,
-		setText,
-		text
-	};
+	})] });
 }
-function AddTypedPassage({ detail, review }) {
-	const { add, setText, text } = useTypedPassage({
+function AttachLinkAction({ detail, review }) {
+	const [isAttaching, setIsAttaching] = useState(false);
+	if (isAttaching) return /* @__PURE__ */ jsx(AttachLink, {
 		detail,
+		onDone: () => setIsAttaching(false),
 		review
 	});
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-form",
-		children: [/* @__PURE__ */ jsx("textarea", {
-			"aria-label": "Add a typed passage",
-			className: "dt-field",
-			maxLength: 5e3,
-			onChange: (event) => setText(event.target.value),
-			placeholder: "Add a typed passage",
-			rows: 2,
-			value: text
-		}), /* @__PURE__ */ jsx("div", {
-			className: "dt-actions",
-			children: /* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				disabled: text.trim() === "",
-				onClick: add,
-				type: "button",
-				children: "Add passage"
-			})
-		})]
+	return /* @__PURE__ */ jsx("div", {
+		className: "dt-actions",
+		children: /* @__PURE__ */ jsx("button", {
+			className: "dt-btn",
+			onClick: () => setIsAttaching(true),
+			type: "button",
+			children: "Attach a link"
+		})
 	});
 }
-function TranscriptTab({ detail, focusSegmentId, review }) {
-	const { canEdit } = detail.session;
-	const timeline = buildTimeline(detail);
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		/* @__PURE__ */ jsx("p", {
-			className: "dt-hint",
-			children: "Audio is deleted once transcribed. You can still correct the text."
-		}),
-		timeline.length === 0 && /* @__PURE__ */ jsx("p", {
-			className: "dt-empty",
-			children: "Nothing was said in this session."
-		}),
-		/* @__PURE__ */ jsx("ol", {
-			className: "dt-ses-timeline",
-			children: timeline.map((item) => "segment" in item ? /* @__PURE__ */ jsx(SegmentRow, {
-				canEdit,
-				isFocused: item.segment.id === focusSegmentId,
-				review,
-				segment: item.segment
-			}, item.key) : /* @__PURE__ */ jsx(TimelineNote, {
-				atMs: item.atMs,
-				children: item.label
-			}, item.key))
-		}),
-		canEdit && /* @__PURE__ */ jsx(AddTypedPassage, {
-			detail,
-			review
-		})
-	] });
+function EvidenceTab({ detail, onShowMoment, review }) {
+	const [enlargedId, setEnlargedId] = useState(null);
+	const [removedId, setRemovedId] = useState(null);
+	const enlarged = detail.evidence.find((item) => item.id === enlargedId && isViewable(item));
+	const removal = {
+		canRemove: detail.session.canEdit,
+		onRemoved: (evidenceId) => {
+			setEnlargedId(null);
+			setRemovedId(evidenceId);
+		},
+		removedId,
+		review
+	};
+	if (enlarged) return /* @__PURE__ */ jsx(EnlargedEvidence, {
+		evidence: enlarged,
+		onBack: () => setEnlargedId(null),
+		removal
+	});
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(EvidenceList, {
+		detail,
+		openers: {
+			onEnlarge: setEnlargedId,
+			onShowMoment
+		},
+		removal
+	}), detail.session.canEdit && /* @__PURE__ */ jsx(AttachLinkAction, {
+		detail,
+		review
+	})] });
 }
 //#endregion
 //#region src/sessions/ui/review/session-review.tsx
 function HandoffFooter({ detail, onHandOff }) {
-	const kept = detail.proposals.filter((proposal) => proposal.decision === "kept" && proposal.mergedIntoId === null).length;
+	const confirmed = detail.proposals.filter((proposal) => proposal.decision === "kept" && proposal.mergedIntoId === null).length;
 	return /* @__PURE__ */ jsxs("div", {
 		className: "dt-sheet-foot",
 		children: [/* @__PURE__ */ jsx("button", {
-			"aria-describedby": kept === 0 ? "rf-handoff-hint" : void 0,
+			"aria-describedby": confirmed === 0 ? "rf-handoff-hint" : void 0,
 			className: "dt-btn",
 			"data-variant": "primary",
-			disabled: kept === 0,
+			disabled: confirmed === 0,
 			onClick: onHandOff,
 			type: "button",
-			children: kept === 0 ? "Hand off" : `Hand off ${kept} kept`
-		}), kept === 0 && /* @__PURE__ */ jsx("span", {
+			children: confirmed === 0 ? "Hand off" : `Hand off ${confirmed} confirmed`
+		}), confirmed === 0 && /* @__PURE__ */ jsx("span", {
 			className: "dt-status",
 			id: "rf-handoff-hint",
-			children: "Keep a proposal to hand it off"
+			children: "Confirm an intention to hand it off"
 		})]
 	});
 }
 function ReviewTabs({ detail, onSelect, tab }) {
 	const options = [
 		{
-			label: `Proposals (${detail.proposals.filter((proposal) => proposal.mergedIntoId === null).length})`,
+			label: `Intentions (${detail.proposals.filter((proposal) => proposal.mergedIntoId === null && proposal.attachment === null).length})`,
 			value: "proposals"
 		},
 		{
@@ -5600,43 +8262,114 @@ function ReviewTabs({ detail, onSelect, tab }) {
 		}, option.value))
 	});
 }
-function ReviewTabPanel({ context, focusSegmentId, tab }) {
-	const { detail, review } = context;
+function ReviewTabPanel({ context, tab }) {
+	const { detail, navigation, review } = context;
 	if (tab === "proposals") return /* @__PURE__ */ jsx(ProposalsTab, { context });
 	if (tab === "transcript") return /* @__PURE__ */ jsx(TranscriptTab, {
 		detail,
-		focusSegmentId,
+		onShowMoment: navigation.onShowMoment,
 		review
 	});
 	return /* @__PURE__ */ jsx(EvidenceTab, {
 		detail,
+		onShowMoment: navigation.onShowMoment,
 		review
 	});
 }
-function useReviewTab() {
+function useReviewPlace() {
 	const [tab, setTab] = useState("proposals");
-	const [focusSegmentId, setFocusSegmentId] = useState(null);
-	const showSegment = (segmentId) => {
-		setFocusSegmentId(segmentId);
-		setTab("transcript");
+	const [focusIntentionId, setFocusIntentionId] = useState(null);
+	const [moment, setMoment] = useState(null);
+	const closeMoment = (shouldReturnFocus) => {
+		const opener = moment?.opener;
+		flushSync(() => setMoment(null));
+		if (shouldReturnFocus && opener?.isConnected) opener.focus();
+	};
+	const showMoment = (segmentId, opener) => {
+		setFocusIntentionId(null);
+		setMoment((current) => ({
+			opener: opener ?? current?.opener ?? null,
+			segmentId
+		}));
 	};
 	return {
-		focusSegmentId,
-		setTab,
-		showSegment,
+		closeMoment,
+		focusIntentionId,
+		moment,
+		openIntention: (proposalId) => {
+			closeMoment(false);
+			setTab("proposals");
+			setFocusIntentionId(proposalId);
+		},
+		selectTab: (next) => {
+			closeMoment(false);
+			setTab(next);
+		},
+		showMoment,
 		tab
 	};
 }
-function ReviewScreen({ detail, onBack, review }) {
-	const { focusSegmentId, setTab, showSegment, tab } = useReviewTab();
+function ReviewPanels({ context, place }) {
+	const { detail, review } = context;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(ReviewTabs, {
+			detail,
+			onSelect: place.selectTab,
+			tab: place.tab
+		}),
+		/* @__PURE__ */ jsx("div", {
+			className: "dt-ses-panel",
+			hidden: place.moment !== null,
+			children: /* @__PURE__ */ jsx(ReviewTabPanel, {
+				context,
+				tab: place.tab
+			})
+		}),
+		place.moment && /* @__PURE__ */ jsx(MomentView, {
+			handlers: {
+				onClose: () => place.closeMoment(true),
+				onOpenIntention: place.openIntention,
+				onShowMoment: (segmentId) => place.showMoment(segmentId)
+			},
+			segmentId: place.moment.segmentId,
+			session: {
+				detail,
+				review
+			}
+		})
+	] });
+}
+function ReviewTop({ context, links }) {
+	const { detail, review } = context;
+	return /* @__PURE__ */ jsxs(Fragment, { children: [
+		/* @__PURE__ */ jsx(ReviewHeader, {
+			onBack: links.onBack,
+			review,
+			session: detail.session
+		}),
+		/* @__PURE__ */ jsx(StatusStrip, {
+			detail,
+			review
+		}),
+		detail.continuation && /* @__PURE__ */ jsx(ContinuationHeader, {
+			continuation: detail.continuation,
+			onOpenSession: links.onOpenSession
+		})
+	] });
+}
+function ReviewScreen({ detail, links, review }) {
+	const place = useReviewPlace();
 	const [isHandingOff, setIsHandingOff] = useState(false);
-	const actions = useProposalActions(review);
-	const { canEdit } = detail.session;
 	const context = {
-		actions,
-		canEdit,
+		actions: useProposalActions(review),
+		canEdit: detail.session.canEdit,
 		detail,
-		onShowSegment: showSegment,
+		focusIntentionId: place.focusIntentionId,
+		navigation: {
+			onOpenSession: links.onOpenSession,
+			onShowMoment: place.showMoment,
+			onStarted: links.onStarted
+		},
 		review
 	};
 	if (isHandingOff) return /* @__PURE__ */ jsx(HandoffView, {
@@ -5645,32 +8378,21 @@ function ReviewScreen({ detail, onBack, review }) {
 		review
 	});
 	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		/* @__PURE__ */ jsx(ReviewHeader, {
-			onBack,
-			review,
-			session: detail.session
-		}),
-		/* @__PURE__ */ jsx(StatusStrip, {
-			detail,
-			review
-		}),
-		/* @__PURE__ */ jsx(ReviewTabs, {
-			detail,
-			onSelect: setTab,
-			tab
+		/* @__PURE__ */ jsx(ReviewTop, {
+			context,
+			links
 		}),
-		/* @__PURE__ */ jsx(ReviewTabPanel, {
+		/* @__PURE__ */ jsx(ReviewPanels, {
 			context,
-			focusSegmentId,
-			tab
+			place
 		}),
-		canEdit && /* @__PURE__ */ jsx(HandoffFooter, {
+		context.canEdit && /* @__PURE__ */ jsx(HandoffFooter, {
 			detail,
 			onHandOff: () => setIsHandingOff(true)
 		})
 	] });
 }
-function SessionReview({ onBack, sessionId }) {
+function SessionReview({ links, sessionId }) {
 	const handle = useSessionDetail(sessionId);
 	const { state } = handle;
 	if (state.kind === "loading") return /* @__PURE__ */ jsx("p", {
@@ -5679,7 +8401,7 @@ function SessionReview({ onBack, sessionId }) {
 	});
 	if (state.kind === "ready") return /* @__PURE__ */ jsx(ReviewScreen, {
 		detail: state.detail,
-		onBack,
+		links,
 		review: handle
 	});
 	return /* @__PURE__ */ jsxs("div", {
@@ -5693,7 +8415,7 @@ function SessionReview({ onBack, sessionId }) {
 				children: "Try again"
 			}), /* @__PURE__ */ jsx("button", {
 				className: "dt-btn",
-				onClick: onBack,
+				onClick: links.onBack,
 				type: "button",
 				children: "All sessions"
 			})]
@@ -5834,141 +8556,6 @@ function SessionList({ drafts, onOpen }) {
 	] });
 }
 //#endregion
-//#region src/sessions/ui/start/session-disclosure.tsx
-const SEEN_KEY_PREFIX = "reflet-sessions-disclosure:";
-function hasSeenDisclosure(accountKey) {
-	try {
-		return localStorage.getItem(`${SEEN_KEY_PREFIX}${accountKey}`) !== null;
-	} catch {
-		return false;
-	}
-}
-function markDisclosureSeen(accountKey) {
-	try {
-		localStorage.setItem(`${SEEN_KEY_PREFIX}${accountKey}`, "1");
-	} catch {}
-}
-function DisclosureList() {
-	return /* @__PURE__ */ jsxs("section", {
-		"aria-labelledby": "rf-session-disclosure",
-		className: "dt-hint",
-		children: [/* @__PURE__ */ jsx("h3", {
-			className: "dt-ses-subhead",
-			id: "rf-session-disclosure",
-			children: "What a session records"
-		}), /* @__PURE__ */ jsxs("ul", {
-			className: "dt-ses-list",
-			children: [
-				/* @__PURE__ */ jsx("li", { children: "Your voice while recording. It is sent to Reflet and transcribed by Whisper through OpenRouter with zero data retention. The audio is deleted as soon as its transcript is saved, within 24 hours at most." }),
-				/* @__PURE__ */ jsx("li", { children: "The page: its address without sensitive parameters, its title, the scroll position and the window size." }),
-				/* @__PURE__ */ jsx("li", { children: "What you click, point at and mark: element names and positions, never your keystrokes." }),
-				/* @__PURE__ */ jsxs("li", { children: [
-					"Screenshots of this tab at the start, when you mark a moment and when the page changes. Form fields appear empty; password fields and elements marked ",
-					/* @__PURE__ */ jsx("code", { children: "data-reflet-redact" }),
-					" are hidden. Other text on screen, rich-text editors included, stays visible."
-				] }),
-				/* @__PURE__ */ jsx("li", { children: "Not recorded: keystrokes, other tabs or apps, network calls." }),
-				/* @__PURE__ */ jsx("li", { children: "Pausing stops everything." }),
-				/* @__PURE__ */ jsx("li", { children: "A session stays private to you until you share it." })
-			]
-		})]
-	});
-}
-function SessionDisclosure({ accountKey }) {
-	const [isOpen, setIsOpen] = useState(() => !hasSeenDisclosure(accountKey));
-	if (isOpen) return /* @__PURE__ */ jsx(DisclosureList, {});
-	return /* @__PURE__ */ jsx("button", {
-		"aria-expanded": false,
-		className: "dt-ses-link",
-		onClick: () => setIsOpen(true),
-		type: "button",
-		children: "What a session records"
-	});
-}
-//#endregion
-//#region src/sessions/ui/start/start-session.tsx
-const IS_MICROPHONE_FAILURE = {
-	auth: false,
-	insecure_context: true,
-	limit: false,
-	mic_blocked_by_site: true,
-	mic_denied: true,
-	mic_unavailable: true,
-	network: false,
-	storage: false
-};
-function StartProblem({ failure, onRetry, onWriteNote }) {
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-ses-problem",
-		role: "alert",
-		children: [/* @__PURE__ */ jsx("p", {
-			className: "dt-error",
-			children: failure.message
-		}), /* @__PURE__ */ jsxs("div", {
-			className: "dt-actions",
-			children: [/* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				onClick: onRetry,
-				type: "button",
-				children: "Try again"
-			}), IS_MICROPHONE_FAILURE[failure.kind] && onWriteNote && /* @__PURE__ */ jsx("button", {
-				className: "dt-btn",
-				onClick: onWriteNote,
-				type: "button",
-				children: "Write a note instead"
-			})]
-		})]
-	});
-}
-function StartActions({ isBusy, onStart, onWriteNote }) {
-	return /* @__PURE__ */ jsxs("div", {
-		className: "dt-actions",
-		children: [/* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			"data-variant": "primary",
-			disabled: isBusy,
-			onClick: onStart,
-			type: "button",
-			children: "Start session"
-		}), onWriteNote && /* @__PURE__ */ jsx("button", {
-			className: "dt-btn",
-			onClick: onWriteNote,
-			type: "button",
-			children: "Write a note instead"
-		})]
-	});
-}
-function StartSession({ onStarted, onWriteNote }) {
-	const { account, recorder } = useSessionWorkspace();
-	const snapshot = useRecorderSnapshot(recorder);
-	const [hasTried, setHasTried] = useState(false);
-	const start = async () => {
-		markDisclosureSeen(account.key);
-		setHasTried(true);
-		await recorder.start({});
-		if (recorder.getSnapshot().phase === "recording") onStarted();
-	};
-	const isRequesting = snapshot.phase === "requesting";
-	const startFailure = hasTried && snapshot.phase === "failed" && snapshot.sessionKey === null ? snapshot.failure : null;
-	return /* @__PURE__ */ jsxs(Fragment, { children: [
-		/* @__PURE__ */ jsx(SessionDisclosure, { accountKey: account.key }),
-		/* @__PURE__ */ jsx("p", {
-			"aria-live": "polite",
-			className: "dt-meta",
-			children: isRequesting ? "Allow the microphone in your browser to start." : ""
-		}),
-		startFailure ? /* @__PURE__ */ jsx(StartProblem, {
-			failure: startFailure,
-			onRetry: start,
-			onWriteNote
-		}) : /* @__PURE__ */ jsx(StartActions, {
-			isBusy: isRequesting || snapshot.phase === "finishing",
-			onStart: start,
-			onWriteNote
-		})
-	] });
-}
-//#endregion
 //#region src/sessions/ui/start/sessions-home.tsx
 function useDraftRecovery({ draft, onOpenSession, onStarted }) {
 	const { account, api, recorder } = useSessionWorkspace();
@@ -6060,7 +8647,14 @@ function SessionsPanel({ navigation, onStarted, onWriteNote }) {
 	const sessionId = useResolvedSessionId(navigation.open);
 	const back = () => navigation.onOpen(null);
 	if (sessionId) return /* @__PURE__ */ jsx(SessionReview, {
-		onBack: back,
+		links: {
+			onBack: back,
+			onOpenSession: (openedId) => navigation.onOpen({
+				sessionId: openedId,
+				sessionKey: null
+			}),
+			onStarted
+		},
 		sessionId
 	}, sessionId);
 	if (navigation.open) return /* @__PURE__ */ jsxs("div", {
@@ -6080,6 +8674,6 @@ function SessionsPanel({ navigation, onStarted, onWriteNote }) {
 	});
 }
 //#endregion
-export { announce as A, searchCode as C, openDatabase as D, describeStorageFailure as E, settle as O, probeDevRoute as S, committed as T, teamTransport as _, DevtoolsBar as a, fetchBoardFeedback as b, copyToClipboard as c, PersonIcon as d, SessionWorkspaceProvider as f, devtoolsTransport as g, purgeAccount as h, BarButton as i, reportFailure as j, Notices as k, SESSIONS_STYLES as l, useWorkspaceLoader as m, DEVTOOLS_STYLES as n, DevtoolsBarButtons as o, failureMessage as p, DevtoolsSheet as r, SessionsBarButton as s, SessionsPanel as t, RecordingLayer as u, callReflet as v, startBoardConnect as w, fetchSourceFile as x, disconnectBoard as y };
+export { Notices as A, searchCode as C, openDatabase as D, describeStorageFailure as E, reportFailure as M, settle as O, probeDevRoute as S, committed as T, teamTransport as _, DevtoolsBar as a, fetchBoardFeedback as b, copyToClipboard as c, PersonIcon as d, SessionWorkspaceProvider as f, devtoolsTransport as g, purgeAccount as h, BarButton as i, announce as j, sessionApiErrorSchema as k, SESSIONS_STYLES as l, useWorkspaceLoader as m, DEVTOOLS_STYLES as n, DevtoolsBarButtons as o, failureMessage as p, DevtoolsSheet as r, SessionsBarButton as s, SessionsPanel as t, RecordingLayer as u, callReflet as v, startBoardConnect as w, fetchSourceFile as x, disconnectBoard as y };
 
-//# sourceMappingURL=sessions-panel-Dq5j1qcu.js.map
+//# sourceMappingURL=sessions-panel-DPhFYhbk.js.map