@xopcai/xopc 0.0.389 → 0.0.391

package/dist/src/discussions/review.js

@@ -0,0 +1,183 @@
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture, listDiscussionTranscriptSegments } from "./repository.js";
+import { readTranscriptRevision, saveTranscriptRevision } from "./revisions.js";
+import { pcmEpoch, playbackRanges, pointToPcm, probeMediaEpoch } from "./media-timeline.js";
+import { z } from "zod";
+//#region src/discussions/review.ts
+init_transaction();
+const anchorSchema = z.object({
+	type: z.enum(["time", "transcript"]),
+	capturedAt: z.number().int().nonnegative(),
+	epoch: z.number().int().min(0).max(100).optional(),
+	coordinate: z.enum(["encoded", "pcm"]).optional(),
+	offsetMs: z.number().min(0).max(8e6).optional(),
+	positionMs: z.number().min(0).max(8e6).optional(),
+	transcriptRevision: z.number().int().nonnegative().optional(),
+	segmentIds: z.array(z.number().int().nonnegative()).min(1).max(100).optional()
+}).strict().refine((anchor) => anchor.type === "transcript" ? anchor.transcriptRevision !== void 0 && !!anchor.segmentIds?.length && anchor.offsetMs === void 0 && anchor.positionMs === void 0 : anchor.transcriptRevision === void 0 && anchor.segmentIds === void 0 && !(anchor.offsetMs !== void 0 && anchor.positionMs !== void 0) && (anchor.offsetMs === void 0 || anchor.epoch !== void 0));
+const inputSchema = z.object({
+	id: z.string().regex(/^[a-zA-Z0-9_-]{1,100}$/),
+	kind: z.enum([
+		"highlight",
+		"question",
+		"note"
+	]),
+	text: z.string().max(4e3),
+	anchor: anchorSchema,
+	expectedRevision: z.number().int().nonnegative(),
+	deleted: z.boolean().optional()
+});
+const map = (row) => ({
+	id: row.id,
+	kind: row.kind,
+	text: row.text,
+	anchor: JSON.parse(row.anchor_json),
+	revision: row.revision,
+	deleted: !!row.deleted,
+	createdAt: row.created_at,
+	updatedAt: row.updated_at
+});
+const requireCapture = (id) => {
+	const capture = getDiscussionCapture(id);
+	if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
+	return capture;
+};
+function listAnnotations(id) {
+	requireCapture(id);
+	return getSqliteDatabase().prepare("SELECT * FROM discussion_annotations WHERE discussion_id=? ORDER BY created_at,id").all(id).map(map).sort((a, b) => a.anchor.capturedAt - b.anchor.capturedAt || a.id.localeCompare(b.id));
+}
+function putAnnotation(id, value) {
+	const parsed = inputSchema.safeParse(value);
+	if (!parsed.success) throw new DiscussionServiceError("invalid_input", "Invalid annotation");
+	const input = parsed.data;
+	return runSqliteWriteTransaction((db) => {
+		const capture = requireCapture(id);
+		if (input.anchor.type === "transcript") {
+			if (input.anchor.transcriptRevision === capture.transcriptRevision) saveTranscriptRevision(id);
+			const segments = readTranscriptRevision(id, input.anchor.transcriptRevision);
+			if (!segments || input.anchor.segmentIds.some((sequence) => !segments.some((segment) => segment.sequence === sequence && segment.status === "confirmed"))) throw new DiscussionServiceError("conflict", "Transcript evidence is no longer available");
+		}
+		const row = db.prepare("SELECT * FROM discussion_annotations WHERE discussion_id=? AND id=?").get(id, input.id);
+		const current = row ? map(row) : void 0;
+		const anchor = JSON.stringify(input.anchor);
+		if (current && current.kind === input.kind && current.text === input.text && current.deleted === !!input.deleted && JSON.stringify(current.anchor) === anchor) return current;
+		if ((current?.revision ?? 0) !== input.expectedRevision) throw new DiscussionServiceError("conflict", "Annotation changed; reload before saving");
+		if (current && JSON.stringify(current.anchor) !== anchor) {
+			const previous = current.anchor;
+			if (!(previous.type === "time" && previous.offsetMs === void 0 && previous.positionMs === void 0 && input.anchor.type === "time" && previous.capturedAt === input.anchor.capturedAt && previous.epoch === input.anchor.epoch && previous.coordinate === input.anchor.coordinate)) throw new DiscussionServiceError("conflict", "Original annotation anchor is immutable");
+		}
+		if (!current && Number(db.prepare("SELECT COUNT(*) n FROM discussion_annotations WHERE discussion_id=?").get(id).n) >= 1e3) throw new DiscussionServiceError("invalid_input", "Annotation limit reached");
+		const now = Date.now();
+		const revision = (current?.revision ?? 0) + 1;
+		db.prepare(`INSERT INTO discussion_annotations(discussion_id,id,kind,text,anchor_json,revision,deleted,created_at,updated_at)
+      VALUES (?,?,?,?,?,?,?,?,?) ON CONFLICT(discussion_id,id) DO UPDATE SET kind=excluded.kind,text=excluded.text,anchor_json=excluded.anchor_json,revision=excluded.revision,deleted=excluded.deleted,updated_at=excluded.updated_at`).run(id, input.id, input.kind, input.text, anchor, revision, input.deleted ? 1 : 0, current?.createdAt ?? now, now);
+		return {
+			id: input.id,
+			kind: input.kind,
+			text: input.text,
+			anchor: input.anchor,
+			revision,
+			deleted: !!input.deleted,
+			createdAt: current?.createdAt ?? now,
+			updatedAt: now
+		};
+	});
+}
+const timingAttempts = /* @__PURE__ */ new Map();
+const timingInFlight = /* @__PURE__ */ new Map();
+async function recordingTimeline(id, notes) {
+	const capture = requireCapture(id);
+	if (!capture.audioAttachmentId || capture.audioDeletedAt || !capture.durationMs) return;
+	const key = `${id}:${capture.audioSha256}`;
+	if (timingInFlight.has(key)) return timingInFlight.get(key);
+	const cached = getSqliteDatabase().prepare("SELECT timeline_json FROM discussion_media_timeline WHERE discussion_id=? AND audio_sha256=?").get(id, capture.audioSha256 ?? "");
+	let previous;
+	try {
+		previous = cached ? JSON.parse(cached.timeline_json) : void 0;
+	} catch {}
+	if (previous && Array.isArray(previous.epochs) && (previous.primary === "pcm" || previous.epochs.every((epoch) => epoch.verified))) return previous;
+	if (capture.mimeType?.includes("wav")) return {
+		primary: "pcm",
+		epochs: [pcmEpoch(capture.durationMs)]
+	};
+	if (previous && Date.now() - (timingAttempts.get(key) ?? 0) < 3e4) return previous;
+	timingAttempts.set(key, Date.now());
+	if (timingAttempts.size > 256) timingAttempts.delete(timingAttempts.keys().next().value);
+	const pending = (async () => {
+		const attachment = await notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
+		if (!attachment) return;
+		const timeline = {
+			primary: "encoded",
+			epochs: [await probeMediaEpoch(attachment.filePath, capture.durationMs, 0, AbortSignal.timeout(35e3))]
+		};
+		if (getDiscussionCapture(id)?.audioSha256 === capture.audioSha256) getSqliteDatabase().prepare("INSERT OR REPLACE INTO discussion_media_timeline(discussion_id,audio_sha256,timeline_json) VALUES(?,?,?)").run(id, capture.audioSha256 ?? "", JSON.stringify(timeline));
+		return timeline;
+	})().finally(() => timingInFlight.delete(key));
+	timingInFlight.set(key, pending);
+	return pending;
+}
+async function evidenceFor(id, revision, ids, notes) {
+	const capture = requireCapture(id);
+	if (!Number.isSafeInteger(revision) || revision < 0 || !ids.length || ids.length > 100 || ids.some((id) => !Number.isSafeInteger(id) || id < 0)) throw new DiscussionServiceError("invalid_input", "Invalid evidence reference");
+	if (capture.transcriptRevision === revision) saveTranscriptRevision(id);
+	const source = readTranscriptRevision(id, revision);
+	if (!source || ids.some((id) => !source.some((segment) => segment.sequence === id && segment.status === "confirmed"))) throw new DiscussionServiceError("not_found", "Referenced transcript revision or segment is unavailable");
+	const attachment = capture.audioAttachmentId && !capture.audioDeletedAt ? await notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId) : null;
+	const timeline = attachment ? await recordingTimeline(id, notes) : void 0;
+	return {
+		transcriptRevision: revision,
+		stale: revision !== getDiscussionCapture(id)?.transcriptRevision,
+		audioAvailable: !!attachment,
+		timingVerified: !!timeline && (timeline.primary === "pcm" || timeline.epochs.every((epoch) => epoch.verified)),
+		segments: source.filter((segment) => ids.includes(segment.sequence)).map((segment) => ({
+			sequence: segment.sequence,
+			startedAtMs: segment.startedAtMs,
+			endedAtMs: segment.endedAtMs,
+			text: segment.displayText ?? segment.rawText ?? "",
+			speakerLabel: segment.speakerLabel,
+			playback: timeline ? playbackRanges(timeline, segment.startedAtMs, segment.endedAtMs) : []
+		}))
+	};
+}
+async function resolvedAnnotations(id, notes) {
+	const capture = requireCapture(id);
+	const annotations = listAnnotations(id);
+	const timeline = await recordingTimeline(id, notes);
+	const current = listDiscussionTranscriptSegments(id).filter((segment) => segment.status === "confirmed");
+	return Promise.all(annotations.map(async (annotation) => {
+		const anchor = annotation.anchor;
+		if (annotation.deleted) return {
+			annotation,
+			state: "unavailable",
+			playback: []
+		};
+		if (anchor.type === "transcript") {
+			const evidence = await evidenceFor(id, anchor.transcriptRevision, anchor.segmentIds, notes).catch(() => void 0);
+			return {
+				annotation,
+				state: evidence ? "located" : "unavailable",
+				evidence,
+				playback: evidence?.segments.flatMap((segment) => segment.playback) ?? []
+			};
+		}
+		const epoch = timeline?.epochs[anchor.epoch ?? 0];
+		const position = anchor.positionMs ?? (epoch && anchor.offsetMs !== void 0 ? anchor.coordinate === "pcm" ? anchor.offsetMs < epoch.durationMs ? epoch.baseMs + anchor.offsetMs : void 0 : pointToPcm(epoch, anchor.offsetMs) : void 0);
+		if (!(!capture.audioDeletedAt && !!capture.audioAttachmentId && position !== void 0 && position >= 0 && position < (capture.durationMs ?? 0))) return {
+			annotation,
+			state: !capture.audioAttachmentId && !capture.audioDeletedAt ? "pending" : "unavailable",
+			playback: []
+		};
+		const refs = current.filter((segment) => segment.startedAtMs <= position && segment.endedAtMs > position).map((segment) => segment.sequence);
+		const evidence = refs.length ? await evidenceFor(id, capture.transcriptRevision, refs, notes) : void 0;
+		return {
+			annotation,
+			state: "located",
+			positionMs: position,
+			playback: timeline ? playbackRanges(timeline, Math.max(0, position - 2e3), Math.min(capture.durationMs, position + 8e3)) : [],
+			evidence
+		};
+	}));
+}
+//#endregion
+export { evidenceFor, listAnnotations, putAnnotation, recordingTimeline, resolvedAnnotations };

package/dist/src/discussions/sealer.d.ts

@@ -1,5 +1,6 @@
 import type { Config } from '../config/schema.js';
 import type { NotesService } from '../notes/service.js';
+import type { STTResult } from '../voice/stt/types.js';
 import type { DiscussionCapture } from './types.js';
 export interface DiscussionSealerDeps {
     processRecordingJob?: () => Promise<void>;
@@ -9,18 +10,23 @@ export interface DiscussionSealerDeps {
         text: string;
         language?: string;
     }>;
+    transcribeSegment?: (audio: Buffer, signal: AbortSignal) => Promise<STTResult>;
+    requestTimeoutMs?: number;
     onUpdated?: (capture: DiscussionCapture) => void;
 }
 export declare class DiscussionSealer {
     private readonly deps;
     private readonly intervalMs;
+    private readonly owner;
     private timer?;
     private running;
+    private recordingRunning;
+    private stopping;
+    private controller?;
     constructor(deps: DiscussionSealerDeps, intervalMs?: number);
     start(): void;
     stop(): Promise<void>;
     tick(now?: number): Promise<void>;
     private sealWhenReady;
     private transcribeFullRecording;
-    private fail;
 }

package/dist/src/discussions/sealer.js

@@ -1,113 +1,189 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { init_transaction, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DISCUSSION_MAX_SAVED_DURATION_MS } from "../../packages/gateway-contract/src/discussions.js";
+import { init_src } from "../../packages/gateway-contract/src/index.js";
+import { init_model_usage, withModelUsageOrigin } from "../providers/model-usage.js";
 import { transcribe } from "../voice/stt/transcribe-core.js";
 import { isSTTAvailable } from "../voice/stt/availability.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
-import { getDiscussionCapture, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
-import { assembleDiscussionTranscript } from "./transcript.js";
+import { listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
+import { appendTranscriptWithoutOverlap, assembleDiscussionTranscript } from "./transcript.js";
 import { replaceTranscriptSegments, saveTranscriptRevision } from "./revisions.js";
+import { assertProcessingRun, claimSealingCapture, ensureProcessingRun, failOrRetryProcessing, getProcessingRun, readCheckpoint, releaseSealingLease, renewSealingLease, resetProcessingRetry, saveCheckpoint, withProcessingDeadline } from "./processing.js";
 import { missingAudioRanges, slicePcmWav } from "./audio-repair.js";
 import { decodeWavToMonoFloat32 } from "../voice/audio/wav.js";
 import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
 import { getRecordingJob } from "./recordingJobs.js";
-import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
 //#region src/discussions/sealer.ts
+init_src();
+init_model_usage();
+init_transaction();
 init_logger();
 const log = createLogger("DiscussionSealer");
 const UPLOAD_GRACE_MS = 2 * 6e4;
 var DiscussionSealer = class {
+	owner = randomUUID();
 	timer;
 	running = false;
+	recordingRunning = false;
+	stopping = false;
+	controller;
 	constructor(deps, intervalMs = 1e3) {
 		this.deps = deps;
 		this.intervalMs = intervalMs;
 	}
 	start() {
 		if (this.timer) return;
-		this.timer = setInterval(() => void this.tick(), this.intervalMs);
+		this.stopping = false;
+		this.timer = setInterval(() => void this.tick().catch((error) => log.error({ err: error }, "Discussion processing tick failed")), this.intervalMs);
 		this.timer.unref();
-		this.tick();
+		this.tick().catch((error) => log.error({ err: error }, "Discussion processing tick failed"));
 	}
 	async stop() {
+		this.stopping = true;
 		if (this.timer) clearInterval(this.timer);
 		this.timer = void 0;
-		while (this.running) await new Promise((resolve) => setTimeout(resolve, 10));
+		this.controller?.abort(/* @__PURE__ */ new Error("Discussion processing stopped"));
+		while (this.running || this.recordingRunning) await new Promise((resolve) => setTimeout(resolve, 10));
 	}
 	async tick(now = Date.now()) {
-		if (this.running) return;
+		if (this.stopping) return;
+		if (!this.recordingRunning) {
+			this.recordingRunning = true;
+			try {
+				await this.deps.processRecordingJob?.();
+			} finally {
+				this.recordingRunning = false;
+			}
+		}
+		if (this.running || this.stopping) return;
 		this.running = true;
+		const controller = new AbortController();
+		this.controller = controller;
+		let capture = null;
+		let renewal;
 		try {
-			await this.deps.processRecordingJob?.();
-			const capture = [...listDiscussionCaptures({
-				status: "sealing",
-				limit: 1
-			}).items, ...listDiscussionCaptures({
-				status: "stopping",
-				limit: 1
-			}).items][0];
+			capture = claimSealingCapture(this.owner, now);
 			if (!capture) return;
-			await this.sealWhenReady(capture, now);
+			const id = capture.id;
+			renewal = setInterval(() => {
+				if (!renewSealingLease(id, this.owner)) controller.abort(/* @__PURE__ */ new Error("Transcription lease lost"));
+			}, 15e3);
+			renewal.unref();
+			await this.sealWhenReady(capture, now, controller.signal);
 		} finally {
+			if (renewal) clearInterval(renewal);
+			if (capture) releaseSealingLease(capture.id, this.owner);
+			this.controller = void 0;
 			this.running = false;
 		}
 	}
-	async sealWhenReady(capture, now) {
+	async sealWhenReady(capture, now, signal) {
 		const ageMs = now - (capture.recordingStoppedAt ?? now);
 		if (!capture.audioAttachmentId) {
 			const job = getRecordingJob(capture.id);
 			if (job && (job.state === "queued" || job.state === "running")) return;
-			if (ageMs >= UPLOAD_GRACE_MS) this.fail(capture, "audio_upload", "recording_missing", "Original recording was not uploaded");
+			if (ageMs >= UPLOAD_GRACE_MS) {
+				const updated = updateDiscussionCapture(capture.id, {
+					status: "needs_attention",
+					failureStage: "audio_upload",
+					failureCode: "recording_missing",
+					failureMessage: "Original recording was not uploaded"
+				}, ["stopping", "sealing"]);
+				if (updated) this.deps.onUpdated?.(updated);
+			}
+			if (ageMs < UPLOAD_GRACE_MS) updateDiscussionCapture(capture.id, { updatedAt: Date.now() }, [capture.status]);
 			return;
 		}
 		const segments = listDiscussionTranscriptSegments(capture.id);
 		const expected = capture.expectedLastSequence ?? -1;
-		const bySequence = new Map(segments.map((segment) => [segment.sequence, segment]));
-		const missing = Array.from({ length: expected + 1 }, (_, sequence) => sequence).filter((sequence) => !bySequence.has(sequence));
+		const missing = expected >= 0 && Array.from({ length: expected + 1 }, (_, sequence) => sequence).some((sequence) => !segments.some((segment) => segment.sequence === sequence));
 		const pending = segments.some((segment) => segment.status === "uploaded" || segment.status === "transcribing");
-		if ((missing.length > 0 || pending) && ageMs < UPLOAD_GRACE_MS) return;
+		const run = ensureProcessingRun(capture);
+		if (!run.force_audio && (missing || pending) && ageMs < UPLOAD_GRACE_MS) {
+			updateDiscussionCapture(capture.id, { updatedAt: Date.now() }, [capture.status]);
+			return;
+		}
 		const sealing = capture.status === "sealing" ? capture : updateDiscussionCapture(capture.id, { status: "sealing" }, ["stopping"]);
 		if (!sealing) return;
 		try {
 			const confirmed = segments.filter((segment) => segment.status === "confirmed");
-			const result = expected >= 0 && missing.length === 0 && !pending && confirmed.length === expected + 1 ? { text: assembleDiscussionTranscript(confirmed) } : await this.transcribeFullRecording(sealing);
+			const result = !run.force_audio && expected >= 0 && !missing && !pending && confirmed.length === expected + 1 ? { text: assembleDiscussionTranscript(confirmed) } : await withModelUsageOrigin("interactive", () => this.transcribeFullRecording(sealing, run, signal));
 			const text = result.text.trim();
-			saveTranscriptRevision(capture.id);
 			if (!text) throw new Error("Discussion transcription produced no text");
-			const updated = updateDiscussionCapture(capture.id, {
-				status: "organizing",
-				canonicalTranscript: text,
-				canonicalTranscriptSha256: createHash("sha256").update(text).digest("hex"),
-				transcriptLanguage: result.language,
-				failureStage: void 0,
-				failureCode: void 0,
-				failureMessage: void 0
-			}, ["sealing"]);
-			if (!updated) throw new Error("Discussion changed while sealing transcript");
-			this.deps.onUpdated?.(updated);
+			const updated = runSqliteWriteTransaction(() => {
+				assertProcessingRun(run, this.owner, signal);
+				if (result.segments) replaceTranscriptSegments(capture.id, result.segments);
+				saveTranscriptRevision(capture.id);
+				resetProcessingRetry(capture.id);
+				return updateDiscussionCapture(capture.id, {
+					status: "organizing",
+					canonicalTranscript: text,
+					canonicalTranscriptSha256: createHash("sha256").update(text).digest("hex"),
+					transcriptLanguage: result.language,
+					failureStage: void 0,
+					failureCode: void 0,
+					failureMessage: void 0
+				}, ["sealing"]);
+			});
+			if (updated) this.deps.onUpdated?.(updated);
 		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			this.fail(sealing, "transcript_sealing", "transcript_sealing_failed", message);
+			if (signal.aborted) return;
+			if (getProcessingRun(capture.id)?.run_id !== run.run_id || !renewSealingLease(capture.id, this.owner)) return;
+			const updated = failOrRetryProcessing(sealing, "transcript_sealing", error);
+			if (updated) this.deps.onUpdated?.(updated);
+			log.warn({
+				err: error,
+				discussionId: capture.id,
+				phase: "transcript_sealing"
+			}, "Discussion transcription failed; saved original retained");
 		}
 	}
-	async transcribeFullRecording(capture) {
+	async transcribeFullRecording(capture, run, signal) {
 		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
 		if (!attachment) throw new Error("Discussion audio file is missing");
+		const assertCurrent = () => assertProcessingRun(run, this.owner, signal);
+		assertCurrent();
+		if (capture.audioSha256) {
+			const hash = createHash("sha256");
+			for await (const chunk of createReadStream(attachment.filePath)) {
+				signal.throwIfAborted();
+				hash.update(chunk);
+			}
+			if (hash.digest("hex") !== capture.audioSha256) throw new Error("Saved original audio checksum mismatch");
+		}
+		assertCurrent();
 		if (this.deps.transcribeRecording) {
-			const result = await this.deps.transcribeRecording(attachment.filePath, capture);
-			replaceTranscriptSegments(capture.id, [{
-				text: result.text,
-				startedAtMs: 0,
-				endedAtMs: capture.durationMs ?? 1e3
-			}]);
-			return result;
+			if (listDiscussionTranscriptSegments(capture.id).some((segment) => segment.correctedByUser)) throw new Error("Segment transcription is required to preserve manual corrections");
+			const cached = readCheckpoint(run.run_id, 0, capture.durationMs ?? 1e3);
+			const result = cached ?? await withProcessingDeadline(async (requestSignal) => {
+				const response = await this.deps.transcribeRecording(attachment.filePath, capture, requestSignal);
+				return {
+					segments: [{
+						text: response.text,
+						startedAtMs: 0,
+						endedAtMs: capture.durationMs ?? 1e3
+					}],
+					language: response.language
+				};
+			}, signal, this.deps.requestTimeoutMs ?? 12e4);
+			assertCurrent();
+			if (!cached) saveCheckpoint(run.run_id, 0, capture.durationMs ?? 1e3, result);
+			return {
+				text: result.segments.map((segment) => segment.text).join("\n"),
+				language: result.language,
+				segments: result.segments
+			};
 		}
 		const config = this.deps.getConfig();
 		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
-		if (!isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
-		let offset = 0;
-		const confirmed = listDiscussionTranscriptSegments(capture.id).filter((segment) => segment.status === "confirmed");
-		const segments = confirmed.map((segment) => ({
+		if (!this.deps.transcribeSegment && !isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
+		const confirmed = listDiscussionTranscriptSegments(capture.id).filter((segment) => segment.status === "confirmed" && (!run.force_audio || segment.correctedByUser));
+		const output = confirmed.map((segment) => ({
 			text: segment.displayText ?? segment.rawText ?? "",
 			rawText: segment.rawText,
 			startedAtMs: segment.startedAtMs,
@@ -115,61 +191,61 @@ var DiscussionSealer = class {
 			speakerLabel: segment.speakerLabel,
 			correctedByUser: segment.correctedByUser
 		}));
+		let offset = 0;
 		let language;
 		await forEachNormalizedAudioSegment({
 			filePath: attachment.filePath,
-			maxDurationSeconds: 7200
+			maxDurationSeconds: DISCUSSION_MAX_SAVED_DURATION_MS / 1e3,
+			signal
 		}, async (buffer, index) => {
+			assertCurrent();
 			const decoded = decodeWavToMonoFloat32(buffer);
 			const durationMs = decoded.durationSeconds * 1e3;
 			const gaps = missingAudioRanges(offset, offset + durationMs, confirmed);
 			for (const [gapIndex, gap] of gaps.entries()) {
-				const audio = gaps.length === 1 && gap.startedAtMs === offset && gap.endedAtMs === offset + durationMs ? buffer : slicePcmWav(decoded, gap.startedAtMs - offset, gap.endedAtMs - offset);
-				if (audio.length <= 44) continue;
-				const result = await transcribe(audio, sttConfig, {
-					mime: "audio/wav",
-					fileName: `discussion-recovery-${index}-${gapIndex}.wav`
-				});
-				if (result.segments?.length) for (const part of result.segments) {
-					if (!Number.isFinite(part.startMs) || !Number.isFinite(part.endMs) || part.startMs < 0 || part.endMs <= part.startMs || part.endMs > gap.endedAtMs - gap.startedAtMs + 100) throw new Error("Provider returned an invalid transcript time range");
-					segments.push({
-						text: part.text,
-						startedAtMs: gap.startedAtMs + part.startMs,
-						endedAtMs: Math.min(gap.endedAtMs, gap.startedAtMs + part.endMs),
-						...part.speaker ? { speakerLabel: `${index + 1}:${gapIndex + 1}:${part.speaker}` } : {}
+				assertCurrent();
+				let checkpoint = readCheckpoint(run.run_id, gap.startedAtMs, gap.endedAtMs);
+				if (!checkpoint) {
+					const audio = gaps.length === 1 && gap.startedAtMs === offset && gap.endedAtMs === offset + durationMs ? buffer : slicePcmWav(decoded, gap.startedAtMs - offset, gap.endedAtMs - offset);
+					if (audio.length <= 44) continue;
+					const result = await withProcessingDeadline((requestSignal) => this.deps.transcribeSegment ? this.deps.transcribeSegment(audio, requestSignal) : transcribe(audio, sttConfig, {
+						mime: "audio/wav",
+						fileName: `discussion-recovery-${index}-${gapIndex}.wav`,
+						signal: requestSignal
+					}), signal, this.deps.requestTimeoutMs ?? 12e4);
+					const recovered = [];
+					if (result.segments?.length) for (const part of result.segments) {
+						if (!Number.isFinite(part.startMs) || !Number.isFinite(part.endMs) || part.startMs < 0 || part.endMs <= part.startMs || part.endMs > gap.endedAtMs - gap.startedAtMs + 100) throw new Error("Provider returned an invalid transcript time range");
+						recovered.push({
+							text: part.text,
+							startedAtMs: gap.startedAtMs + part.startMs,
+							endedAtMs: Math.min(gap.endedAtMs, gap.startedAtMs + part.endMs),
+							...part.speaker ? { speakerLabel: `${index + 1}:${gapIndex + 1}:${part.speaker}` } : {}
+						});
+					}
+					else if (result.text.trim()) recovered.push({
+						text: result.text,
+						...gap
 					});
+					checkpoint = {
+						segments: recovered,
+						language: result.language
+					};
+					assertCurrent();
+					saveCheckpoint(run.run_id, gap.startedAtMs, gap.endedAtMs, checkpoint);
 				}
-				else if (result.text.trim()) segments.push({
-					text: result.text,
-					...gap
-				});
-				language ??= result.language;
+				output.push(...checkpoint.segments);
+				language ??= checkpoint.language;
 			}
 			offset += durationMs;
 		});
-		segments.sort((a, b) => a.startedAtMs - b.startedAtMs);
-		replaceTranscriptSegments(capture.id, segments);
+		output.sort((a, b) => a.startedAtMs - b.startedAtMs);
 		return {
-			text: assembleDiscussionTranscript(listDiscussionTranscriptSegments(capture.id)),
-			...language ? { language } : {}
+			text: output.reduce((text, segment) => appendTranscriptWithoutOverlap(text, segment.text), ""),
+			language,
+			segments: output
 		};
 	}
-	fail(capture, stage, code, message) {
-		const current = getDiscussionCapture(capture.id);
-		if (!current || current.status !== "stopping" && current.status !== "sealing") return;
-		const updated = updateDiscussionCapture(capture.id, {
-			status: "needs_attention",
-			failureStage: stage,
-			failureCode: code,
-			failureMessage: message.slice(0, 1e3)
-		}, [current.status]);
-		if (updated) this.deps.onUpdated?.(updated);
-		log.warn({
-			discussionId: capture.id,
-			stage,
-			code
-		}, `Discussion sealing failed: ${message}`);
-	}
 };
 //#endregion
 export { DiscussionSealer };

package/dist/src/discussions/service.d.ts

@@ -1,3 +1,4 @@
+import { longRecordingReview } from './long-review.js';
 import { type DiscussionRecordingManifest } from '@xopcai/gateway-contract';
 import type { NotesService } from '../notes/service.js';
 import type { ProjectService } from '../projects/project-service.js';
@@ -15,6 +16,10 @@ export declare class DiscussionService {
     private readonly recordingOwner;
     private readonly recordingControllers;
     constructor(notes: NotesService, projects: ProjectService, emit?: (type: string, payload: unknown) => void);
+    audioClip(id: string, start: number, end: number, signal: AbortSignal): Promise<Buffer<ArrayBufferLike>>;
+    annotations(id: string): Promise<import("@xopcai/gateway-contract").DiscussionResolvedAnnotation[]>;
+    saveAnnotation(id: string, input: import('@xopcai/gateway-contract').DiscussionAnnotationInput): import("@xopcai/gateway-contract").DiscussionAnnotation;
+    evidence(id: string, revision: number, ids: number[]): Promise<import("@xopcai/gateway-contract").DiscussionEvidence>;
     settings(): DiscussionCaptureSettings;
     acknowledgeConsent(policyVersion: number): DiscussionCaptureSettings;
     create(input: CreateDiscussionInput): Promise<DiscussionDetail>;
@@ -44,10 +49,11 @@ export declare class DiscussionService {
     sealRecording(id: string, input: DiscussionRecordingManifest): Promise<import("@xopcai/gateway-contract").DiscussionRecordingJob>;
     /** Runs inside the existing sealer lifecycle; unfinished leases survive process restart. */
     processRecordingJob(): Promise<void>;
-    retry(id: string): Promise<DiscussionDetail | null>;
+    retry(id: string, mode?: import('./types.js').DiscussionRetryMode): Promise<DiscussionDetail | null>;
     cancel(id: string): Promise<DiscussionDetail | null>;
     deleteAudio(id: string): Promise<DiscussionDetail | null>;
     unlinkInferredProject(id: string): Promise<DiscussionDetail | null>;
+    review(id: string, options?: Parameters<typeof longRecordingReview>[2]): Promise<import("@xopcai/gateway-contract").DiscussionReview>;
     private detail;
     private enqueueMutation;
 }