@xopcai/xopc 0.0.388 → 0.0.390

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 { isSTTAvailable } from "../voice/stt/availability.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;
 }

package/dist/src/discussions/service.js

@@ -8,6 +8,10 @@ import { DiscussionServiceError } from "./errors.js";
 import { acknowledgeDiscussionCaptureConsent, correctDiscussionTranscriptSegment, createDiscussionCapture, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, getLatestDiscussionOrganization, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
 import { assembleDiscussionTranscript } from "./transcript.js";
 import { readTranscriptRevision, refreshCanonicalTranscript, saveTranscriptRevision } from "./revisions.js";
+import { createProcessingRun, processingProgress, resetProcessingRetry } from "./processing.js";
+import { evidenceFor, putAnnotation, resolvedAnnotations } from "./review.js";
+import { longRecordingReview } from "./long-review.js";
+import { discussionAudioClip } from "./audio-clip.js";
 import { editMeeting } from "./edits.js";
 import { completeRecording, listRecordingChunks, removeRecordingChunks, saveRecordingChunk, validateRecordingManifest } from "./recording.js";
 import { cancelRecordingJob, claimRecordingJob, finishRecordingJob, getRecordingJob, getRecordingJobInput, renewRecordingJob, submitRecordingJob } from "./recordingJobs.js";
@@ -31,6 +35,18 @@ var DiscussionService = class {
 		this.projects = projects;
 		this.emit = emit;
 	}
+	audioClip(id, start, end, signal) {
+		return discussionAudioClip(id, start, end, this.notes, signal);
+	}
+	annotations(id) {
+		return resolvedAnnotations(id, this.notes);
+	}
+	saveAnnotation(id, input) {
+		return putAnnotation(id, input);
+	}
+	evidence(id, revision, ids) {
+		return evidenceFor(id, revision, ids, this.notes);
+	}
 	settings() {
 		return getDiscussionCaptureSettings();
 	}
@@ -238,6 +254,7 @@ var DiscussionService = class {
 			const capture = getDiscussionCapture(id);
 			if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
 			if (!["completed", "needs_attention"].includes(capture.status) || !capture.canonicalTranscript) throw new DiscussionServiceError("conflict", "Transcript is not ready");
+			resetProcessingRetry(id);
 			const updated = updateDiscussionCapture(id, {
 				status: "organizing",
 				template,
@@ -338,24 +355,37 @@ var DiscussionService = class {
 			}
 		});
 	}
-	async retry(id) {
-		const capture = getDiscussionCapture(id);
-		if (!capture) return null;
-		if (capture.status !== "needs_attention") throw new DiscussionServiceError("conflict", "Only discussions needing attention can be retried");
-		if (getRecordingJob(id)?.state === "failed") {
+	async retry(id, mode = "resume") {
+		if (mode !== "resume" && mode !== "from_audio") throw new DiscussionServiceError("invalid_input", "Invalid retry mode");
+		if (mode === "resume" && getRecordingJob(id)?.state === "failed") {
 			await this.sealRecording(id, getRecordingJobInput(id));
 			return this.get(id);
 		}
-		const updated = updateDiscussionCapture(id, {
-			status: capture.canonicalTranscript ? "organizing" : "stopping",
-			...!capture.canonicalTranscript ? { recordingStoppedAt: Date.now() } : {},
-			failureStage: void 0,
-			failureCode: void 0,
-			failureMessage: void 0
-		}, ["needs_attention"]);
-		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while retrying");
-		this.emit?.("discussion.updated", updated);
-		return this.detail(updated);
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (mode === "from_audio") {
+				if (!["completed", "needs_attention"].includes(capture.status)) throw new DiscussionServiceError("conflict", "Wait for current processing to finish");
+				if (!capture.audioAttachmentId || capture.audioDeletedAt || !await this.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId)) throw new DiscussionServiceError("conflict", "Saved original audio is unavailable");
+			} else if (capture.status !== "needs_attention") throw new DiscussionServiceError("conflict", "Only discussions needing attention can be retried");
+			const updated = runSqliteWriteTransaction(() => {
+				if (mode === "from_audio") {
+					saveTranscriptRevision(id);
+					createProcessingRun(capture, true);
+				} else resetProcessingRetry(id);
+				const status = mode === "from_audio" || capture.failureStage === "transcript_sealing" ? "sealing" : capture.canonicalTranscript ? "organizing" : "stopping";
+				return updateDiscussionCapture(id, {
+					status,
+					...status === "stopping" ? { recordingStoppedAt: Date.now() } : {},
+					failureStage: void 0,
+					failureCode: void 0,
+					failureMessage: void 0
+				}, [capture.status]);
+			});
+			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while retrying");
+			this.emit?.("discussion.updated", updated);
+			return this.detail(updated);
+		});
 	}
 	async cancel(id) {
 		const active = getDiscussionCapture(id);
@@ -389,6 +419,8 @@ var DiscussionService = class {
 			await removeRecordingChunks(capture);
 			cancelRecordingJob(id);
 			if (capture.audioAttachmentId) await this.notes.removeAttachment(capture.noteId, capture.audioAttachmentId);
+			const sourceNote = await this.notes.getNote(capture.noteId);
+			for (const attachment of sourceNote?.attachments ?? []) if (attachment.retainWithoutReference && (attachment.fileName.startsWith(`recording-part-${capture.id}-`) || attachment.fileName === `recording-sources-${capture.id}.json` || attachment.fileName === `recording-events-${capture.id}.json`)) await this.notes.removeAttachment(capture.noteId, attachment.id);
 			deleteDiscussionSegmentAudio(id);
 			const updated = updateDiscussionCapture(id, {
 				audioAttachmentId: void 0,
@@ -413,12 +445,16 @@ var DiscussionService = class {
 		this.emit?.("discussion.updated", updated);
 		return this.detail(updated);
 	}
+	review(id, options = {}) {
+		return longRecordingReview(id, this.notes, options);
+	}
 	async detail(capture) {
 		const note = await this.notes.getNote(capture.noteId);
 		if (!note) throw new DiscussionServiceError("not_found", "Discussion note not found");
 		const recordingJob = getRecordingJob(capture.id);
 		return {
 			discussion: capture,
+			processing: processingProgress(capture.id),
 			note,
 			transcript: this.transcript(capture.id),
 			...recordingJob ? { recordingJob } : {},

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

@@ -1,10 +1,11 @@
 export { DISCUSSION_STATUSES } from '@xopcai/gateway-contract';
-export type { DiscussionStatus, DiscussionSource, DiscussionProjectInferenceSource, DiscussionFailureStage, DiscussionFact, DiscussionChapter, DiscussionTemplate, DiscussionActionItem, DiscussionOrganization, DiscussionCapture, DiscussionTranscriptSegmentStatus, DiscussionTranscriptSegment, DiscussionTranscriptStats, DiscussionTranscript, DiscussionOrganizationRecord, DiscussionCaptureSettings, CreateDiscussionInput, ListDiscussionsQuery, DiscussionListResult, DiscussionMetrics, } from '@xopcai/gateway-contract';
+export type { DiscussionStatus, DiscussionSource, DiscussionProjectInferenceSource, DiscussionFailureStage, DiscussionFact, DiscussionChapter, DiscussionTemplate, DiscussionActionItem, DiscussionOrganization, DiscussionCapture, DiscussionTranscriptSegmentStatus, DiscussionTranscriptSegment, DiscussionTranscriptStats, DiscussionTranscript, DiscussionOrganizationRecord, DiscussionCaptureSettings, CreateDiscussionInput, ListDiscussionsQuery, DiscussionListResult, DiscussionMetrics, DiscussionProcessingProgress, DiscussionRetryMode, } from '@xopcai/gateway-contract';
 import type { DiscussionCapture, DiscussionTranscript, DiscussionOrganizationRecord } from '@xopcai/gateway-contract';
 export interface DiscussionDetail {
     discussion: DiscussionCapture;
     note: import('../notes/types.js').Note;
     transcript: DiscussionTranscript;
     organization?: DiscussionOrganizationRecord;
+    processing?: import('@xopcai/gateway-contract').DiscussionProcessingProgress;
     recordingJob?: import('@xopcai/gateway-contract').DiscussionRecordingJob;
 }

package/dist/src/endpoint-tools/index.js

@@ -1,6 +1,6 @@
-import { EndpointBindingService } from "./binding-service.js";
 import { EndpointToolPolicy, EndpointToolPolicyError } from "./policy.js";
 import { EndpointInvocationService, EndpointToolExecutionError } from "./invocation-service.js";
+import { EndpointBindingService } from "./binding-service.js";
 import { EndpointRegistry, endpointToolRevision } from "./registry.js";
 import { ENDPOINT_UPLOAD_MAX_BYTES, EndpointUploadError, EndpointUploadService } from "./upload-service.js";
 import { EndpointToolRuntime } from "./runtime.js";

package/dist/src/endpoint-tools/runtime.js

@@ -7,12 +7,12 @@ import { bindEndpointPrincipal, getEndpointPrincipal, touchEndpointPrincipal } f
 import { finishEndpointToolInvocationAudit, startEndpointToolInvocationAudit } from "../storage/sqlite/endpoint-tool-invocation-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { init_paths } from "../config/paths.js";
+import { EndpointToolPolicy } from "./policy.js";
+import { EndpointInvocationService } from "./invocation-service.js";
 import { EndpointAuthenticator } from "./auth.js";
 import { EndpointBindingService } from "./binding-service.js";
 import { DeviceGrantService } from "./grant-service.js";
 import { recordDeviceGrantEvent } from "../storage/sqlite/device-grant-audit-repository.js";
-import { EndpointToolPolicy } from "./policy.js";
-import { EndpointInvocationService } from "./invocation-service.js";
 import { EndpointRegistry } from "./registry.js";
 import { EndpointUploadService } from "./upload-service.js";
 import { join } from "node:path";

package/dist/src/extensions/activation-context.js

@@ -1,12 +1,12 @@
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { PROVIDER_ENV_MAP, init_env_keys } from "../providers/env-keys.js";
 import { init_providers, isProviderConfiguredSync } from "../providers/index.js";
-import { collectTtsProviderConfigEntries } from "../voice/tts/config-slice.js";
-import { isProviderConfigured } from "../voice/tts/factory.js";
-import { mergeTtsConfigFromAppConfig } from "../voice/tts/merge-config.js";
 import { collectSttProviderConfigEntries } from "../voice/stt/config-slice.js";
 import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
 import "../voice/stt/index.js";
+import { collectTtsProviderConfigEntries } from "../voice/tts/config-slice.js";
+import { isProviderConfigured } from "../voice/tts/factory.js";
+import { mergeTtsConfigFromAppConfig } from "../voice/tts/merge-config.js";
 import { isSttProviderConfigured } from "../voice/stt/list-providers.js";
 //#region src/extensions/activation-context.ts
 init_providers();

package/dist/src/extensions/agent-plugins/auth.js

@@ -1,8 +1,8 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
 import { init_write_file_atomic, writeTextAtomic } from "../../infra/write-file-atomic.js";
+import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { isDangerousHostEnvVarName } from "../../infra/host-env-security.js";
 import { pluginName } from "./validation.js";
-import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { join } from "node:path";
 import { existsSync, readFileSync } from "node:fs";
 import { createHash } from "node:crypto";

package/dist/src/extensions/agent-plugins/credentials.js

@@ -1,6 +1,6 @@
 import { init_paths_state, resolveStateDir } from "../../config/paths-state.js";
-import { pluginName } from "./validation.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
+import { pluginName } from "./validation.js";
 import { pluginCredentialProviderPrefix } from "./auth.js";
 import { join } from "node:path";
 import { existsSync, rmSync } from "node:fs";

package/dist/src/extensions/agent-plugins/source-http-fetch.js

@@ -1,5 +1,5 @@
-import { Agent, fetch } from "undici";
 import { BlockList, isIP } from "node:net";
+import { Agent, fetch } from "undici";
 import { lookup } from "node:dns";
 //#region src/extensions/agent-plugins/source-http-fetch.ts
 const blocked = new BlockList();

package/dist/src/extensions/api.js

@@ -1,14 +1,14 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { getProviderRegistry, init_plugin_registry } from "../providers/plugin-registry.js";
-import { registerMigration } from "../migrations/registry.js";
-import { registerSpeechProvider } from "../voice/tts/speech-registry.js";
+import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { registerMediaUnderstandingProvider } from "../media-understanding/registry.js";
-import { commandRegistry } from "../chat-commands/registry.js";
+import { registerSpeechProvider } from "../voice/tts/speech-registry.js";
 import { HOOK_EXECUTION_MODES } from "./types/hooks.js";
+import { commandRegistry } from "../chat-commands/registry.js";
 import { TypedEventBus } from "./typed-event-bus.js";
 import { ExtensionRegistryImpl } from "./extension-registry-impl.js";
+import { registerMigration } from "../migrations/registry.js";
 import { isAbsolute, resolve } from "path";
 import { EventEmitter } from "events";
 //#region src/extensions/api.ts

package/dist/src/extensions/bundled-extension-activation.js

@@ -1,5 +1,5 @@
-import { mergeActivationContext } from "./activation-context.js";
 import { ActivationPlanner } from "./activation-planner.js";
+import { mergeActivationContext } from "./activation-context.js";
 //#region src/extensions/bundled-extension-activation.ts
 function asSurfaceConfig(config) {
 	return config;

package/dist/src/extensions/index.js

@@ -1,14 +1,14 @@
 import { normalizeExtensionManifest } from "./normalize-manifest.js";
 import { areExtensionsGloballyDisabled, discoverExtensionsFromDisk } from "./discover-extensions.js";
-import { ManifestRegistry } from "./manifest-registry.js";
-import { buildExtensionMetadataSnapshot, resolveExtensionLoaderOptionsFromConfig } from "./extension-metadata-snapshot.js";
-import { collectConfiguredChannelIds, collectConfiguredProviderIds, mergeActivationContext } from "./activation-context.js";
 import { HOOK_EXECUTION_MODES } from "./types/hooks.js";
 import { BUILTIN_PROVIDERS } from "./types/providers.js";
 import { ExtensionRegistryImpl } from "./extension-registry-impl.js";
 import { ExtensionApiImpl, createExtensionLogger, createPathResolver } from "./api.js";
 import { ActivationPlanner } from "./activation-planner.js";
+import { collectConfiguredChannelIds, collectConfiguredProviderIds, mergeActivationContext } from "./activation-context.js";
+import { ManifestRegistry } from "./manifest-registry.js";
 import { ExtensionLoader, normalizeExtensionConfig, resolveExtensionPath } from "./loader.js";
 import { listOnboardChannels, listOnboardProviders, resolveProviderForModel } from "./onboard-helpers.js";
+import { buildExtensionMetadataSnapshot, resolveExtensionLoaderOptionsFromConfig } from "./extension-metadata-snapshot.js";
 import { ExtensionHookRunner, createHookContext, isHookEvent } from "./hooks.js";
 export { ActivationPlanner, BUILTIN_PROVIDERS, ExtensionApiImpl, ExtensionHookRunner, ExtensionLoader, ExtensionRegistryImpl, HOOK_EXECUTION_MODES, ManifestRegistry, areExtensionsGloballyDisabled, buildExtensionMetadataSnapshot, collectConfiguredChannelIds, collectConfiguredProviderIds, createExtensionLogger, createHookContext, createPathResolver, discoverExtensionsFromDisk, isHookEvent, listOnboardChannels, listOnboardProviders, mergeActivationContext, normalizeExtensionConfig, normalizeExtensionManifest, resolveExtensionLoaderOptionsFromConfig, resolveExtensionPath, resolveProviderForModel };

package/dist/src/extensions/install.js

@@ -9,8 +9,8 @@ import { collectExtensionPackageDependencyIssues } from "./package-contract.js";
 import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";
 import { execFileSync } from "node:child_process";
-import AdmZip from "adm-zip";
 import semver from "semver";
+import AdmZip from "adm-zip";
 import { tmpdir } from "os";
 //#region src/extensions/install.ts
 /**