@xopcai/xopc 0.0.278 → 0.0.283

package/dist/src/discussions/recording.js

@@ -0,0 +1,219 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DISCUSSION_MAX_DURATION_MS } from "../../packages/gateway-contract/src/discussions.js";
+import { decodeWavToMonoFloat32 } from "../voice/local/wav.js";
+import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
+import { DiscussionServiceError } from "./errors.js";
+import { getDiscussionCapture, updateDiscussionCapture } from "./repository.js";
+import { resolveNoteMediaDir } from "../notes/paths.js";
+import { join } from "node:path";
+import { createReadStream } from "node:fs";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+//#region src/discussions/recording.ts
+const invalid = (message) => new DiscussionServiceError("invalid_input", message);
+const directory = (capture) => join(resolveNoteMediaDir(capture.noteId), ".recording");
+function listRecordingChunks(id) {
+	return getSqliteDatabase().prepare("SELECT sequence, sha256, bytes FROM discussion_recording_chunks WHERE discussion_id = ? ORDER BY sequence").all(id);
+}
+/** Called under the discussion mutation queue. Receipt follows durable disk write. */
+async function saveRecordingChunk(capture, sequence, sha256, body) {
+	if (!Number.isSafeInteger(sequence) || sequence < 0 || sequence > 1e4 || !/^[a-f0-9]{64}$/.test(sha256)) throw invalid("Invalid recording chunk metadata");
+	const chunks = listRecordingChunks(capture.id);
+	const existing = chunks.find((chunk) => chunk.sequence === sequence);
+	if (existing) {
+		await body.cancel();
+		if (existing.sha256 !== sha256) throw new DiscussionServiceError("conflict", "Chunk already contains different audio");
+		return existing;
+	}
+	const root = directory(capture);
+	await mkdir(root, { recursive: true });
+	const temporary = join(root, `${sequence}-${randomUUID()}.tmp`);
+	const file = await open(temporary, "wx");
+	const reader = body.getReader();
+	const hash = createHash("sha256");
+	let bytes = 0;
+	const previousBytes = chunks.reduce((total, chunk) => total + chunk.bytes, 0);
+	try {
+		while (true) {
+			const next = await reader.read();
+			if (next.done) break;
+			bytes += next.value.byteLength;
+			if (bytes > 8388608 || previousBytes + bytes > 1073741824) throw invalid("Recording exceeds upload size limit");
+			hash.update(next.value);
+			await file.writeFile(next.value);
+		}
+		if (!bytes || hash.digest("hex") !== sha256) throw invalid("Recording chunk checksum mismatch");
+		await file.sync();
+		await file.close();
+		const latest = getDiscussionCapture(capture.id);
+		if (!latest || latest.status === "cancelled" || latest.audioDeletedAt) throw new DiscussionServiceError("conflict", "Recording was deleted or cancelled");
+		await rename(temporary, join(root, String(sequence)));
+		const dir = await open(root, "r");
+		try {
+			await dir.sync();
+		} finally {
+			await dir.close();
+		}
+		getSqliteDatabase().prepare("INSERT INTO discussion_recording_chunks (discussion_id, sequence, sha256, bytes) VALUES (?, ?, ?, ?)").run(capture.id, sequence, sha256, bytes);
+		return {
+			sequence,
+			sha256,
+			bytes
+		};
+	} finally {
+		await reader.cancel().catch(() => void 0);
+		await file.close().catch(() => void 0);
+		await rm(temporary, { force: true });
+	}
+}
+function validateRecordingManifest(capture, input) {
+	if (input.containerMode !== void 0 && (input.containerMode !== "independent_wav" || input.mimeType !== "audio/wav")) throw invalid("Unsupported recording container");
+	const mimeType = input.mimeType.split(";")[0];
+	if (![
+		"audio/wav",
+		"audio/x-wav",
+		"audio/webm",
+		"audio/ogg",
+		"audio/mpeg",
+		"audio/mp4"
+	].includes(mimeType)) throw invalid("Unsupported audio type");
+	const chunks = listRecordingChunks(capture.id);
+	if (!Number.isSafeInteger(input.chunkCount) || input.chunkCount < 1 || chunks.length !== input.chunkCount || chunks.some((chunk, index) => chunk.sequence !== index)) throw invalid("Recording has missing chunks");
+}
+async function completeRecording(capture, input, notes, assertLease, signal) {
+	validateRecordingManifest(capture, input);
+	const chunks = listRecordingChunks(capture.id);
+	const target = join(directory(capture), `assembled-${randomUUID()}`);
+	const file = await open(target, "w");
+	const hash = createHash("sha256");
+	try {
+		try {
+			if (input.containerMode === "independent_wav") {
+				const samples = chunks.reduce((total, chunk) => total + (chunk.bytes - 44) / 2, 0);
+				if (!Number.isSafeInteger(samples) || samples <= 0 || samples > 16e3 * 72e5 / 1e3) throw invalid("Invalid PCM recording duration");
+				const header = recordingWavHeader(samples);
+				hash.update(header);
+				await file.writeFile(header);
+			}
+			for (const chunk of chunks) {
+				const chunkHash = createHash("sha256");
+				let bytes = 0;
+				try {
+					if (input.containerMode === "independent_wav") {
+						signal.throwIfAborted();
+						const buffers = [];
+						for await (const buffer of createReadStream(join(directory(capture), String(chunk.sequence)))) {
+							signal.throwIfAborted();
+							bytes += buffer.length;
+							if (bytes > 8388608 || bytes > chunk.bytes) throw invalid("Stored WAV chunk is corrupt");
+							buffers.push(buffer);
+						}
+						const data = Buffer.concat(buffers, bytes);
+						if (data.length !== chunk.bytes || data.length <= 44 || data.length > 8388608 || data.length % 2 !== 0 || !data.subarray(0, 44).equals(recordingWavHeader((data.length - 44) / 2)) || createHash("sha256").update(data).digest("hex") !== chunk.sha256) throw invalid("Stored WAV chunk is corrupt");
+						hash.update(data.subarray(44));
+						await file.writeFile(data.subarray(44));
+						continue;
+					}
+					for await (const buffer of createReadStream(join(directory(capture), String(chunk.sequence)))) {
+						signal.throwIfAborted();
+						hash.update(buffer);
+						chunkHash.update(buffer);
+						bytes += buffer.length;
+						await file.writeFile(buffer);
+					}
+					if (bytes !== chunk.bytes || chunkHash.digest("hex") !== chunk.sha256) throw invalid("Stored recording chunk is corrupt");
+				} catch (error) {
+					if (!signal.aborted && (error instanceof DiscussionServiceError || error.code === "ENOENT")) {
+						assertLease();
+						getSqliteDatabase().prepare("DELETE FROM discussion_recording_chunks WHERE discussion_id=? AND sequence=?").run(capture.id, chunk.sequence);
+					}
+					throw error;
+				}
+			}
+			await file.sync();
+		} finally {
+			await file.close();
+		}
+		let durationMs = 0;
+		await forEachNormalizedAudioSegment({
+			filePath: target,
+			segmentSeconds: 30,
+			maxDurationSeconds: DISCUSSION_MAX_DURATION_MS / 1e3,
+			signal: AbortSignal.any([signal, AbortSignal.timeout(18e4)])
+		}, async (buffer) => {
+			durationMs += decodeWavToMonoFloat32(buffer).durationSeconds * 1e3;
+		});
+		if (durationMs < 1e3) throw invalid("Recording must contain at least one second of audio");
+		const latest = getDiscussionCapture(capture.id);
+		if (!latest || latest.status === "cancelled" || latest.audioDeletedAt) throw new DiscussionServiceError("conflict", "Recording was deleted or cancelled");
+		assertLease();
+		const audioSha256 = hash.digest("hex");
+		const attachment = await notes.addAttachment(capture.noteId, {
+			name: input.fileName.trim().slice(0, 200) || "meeting.webm",
+			buffer: { filePath: target },
+			mimeType: input.mimeType,
+			duration: Math.round(durationMs / 1e3),
+			retainWithoutReference: true
+		}, `meeting-recording:${capture.id}`);
+		if (!attachment) throw new DiscussionServiceError("not_found", "Discussion note not found");
+		const persisted = await notes.getAttachmentPath(capture.noteId, attachment.id);
+		if (!persisted) throw new Error("Saved recording file is missing");
+		const savedFile = await open(persisted.filePath, "r");
+		try {
+			await savedFile.sync();
+		} finally {
+			await savedFile.close();
+		}
+		const savedDirectory = await open(resolveNoteMediaDir(capture.noteId), "r");
+		try {
+			await savedDirectory.sync();
+		} finally {
+			await savedDirectory.close();
+		}
+		const updated = runSqliteWriteTransaction(() => {
+			assertLease();
+			return updateDiscussionCapture(capture.id, {
+				status: "stopping",
+				audioAttachmentId: attachment.id,
+				mimeType: input.mimeType,
+				audioSha256,
+				durationMs: Math.round(durationMs),
+				audioSizeBytes: chunks.reduce((sum, chunk) => sum + chunk.bytes, 0)
+			}, [
+				"recording",
+				"stopping",
+				"needs_attention"
+			]);
+		});
+		if (!updated) throw new DiscussionServiceError("conflict", "Recording changed while completing");
+		await removeRecordingChunks(capture);
+		return updated;
+	} finally {
+		await rm(target, { force: true });
+	}
+}
+function recordingWavHeader(samples) {
+	const header = Buffer.alloc(44);
+	header.write("RIFF");
+	header.writeUInt32LE(36 + samples * 2, 4);
+	header.write("WAVEfmt ", 8);
+	header.writeUInt32LE(16, 16);
+	header.writeUInt16LE(1, 20);
+	header.writeUInt16LE(1, 22);
+	header.writeUInt32LE(16e3, 24);
+	header.writeUInt32LE(32e3, 28);
+	header.writeUInt16LE(2, 32);
+	header.writeUInt16LE(16, 34);
+	header.write("data", 36);
+	header.writeUInt32LE(samples * 2, 40);
+	return header;
+}
+async function removeRecordingChunks(capture) {
+	await rm(directory(capture), {
+		recursive: true,
+		force: true
+	});
+	getSqliteDatabase().prepare("DELETE FROM discussion_recording_chunks WHERE discussion_id = ?").run(capture.id);
+}
+//#endregion
+export { completeRecording, listRecordingChunks, removeRecordingChunks, saveRecordingChunk, validateRecordingManifest };

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

@@ -0,0 +1,14 @@
+import type { DiscussionRecordingJob, DiscussionRecordingManifest } from '@xopcai/gateway-contract';
+export declare function getRecordingJob(discussionId: string): DiscussionRecordingJob | null;
+export declare function getRecordingJobInput(discussionId: string): DiscussionRecordingManifest | null;
+export declare function submitRecordingJob(discussionId: string, input: DiscussionRecordingManifest): DiscussionRecordingJob;
+export declare function claimRecordingJob(owner: string, now?: number): {
+    input: DiscussionRecordingManifest;
+    id: string;
+    discussionId: string;
+    state: "queued" | "running" | "completed" | "failed" | "cancelled";
+    error?: string;
+};
+export declare function renewRecordingJob(id: string, owner: string, now?: number): boolean;
+export declare function finishRecordingJob(id: string, owner: string, error?: string): boolean;
+export declare function cancelRecordingJob(discussionId: string): void;

package/dist/src/discussions/recordingJobs.js

@@ -0,0 +1,69 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DiscussionServiceError } from "./errors.js";
+import { listRecordingChunks } from "./recording.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/discussions/recordingJobs.ts
+const LEASE_MS = 6e4;
+function mapJob(row) {
+	return {
+		id: row.id,
+		discussionId: row.discussion_id,
+		state: row.state,
+		...row.error ? { error: row.error } : {}
+	};
+}
+function getRecordingJob(discussionId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM discussion_recording_jobs WHERE discussion_id=?").get(discussionId);
+	return row ? mapJob(row) : null;
+}
+function getRecordingJobInput(discussionId) {
+	const row = getSqliteDatabase().prepare("SELECT input_json FROM discussion_recording_jobs WHERE discussion_id=?").get(discussionId);
+	return row ? JSON.parse(row.input_json) : null;
+}
+function submitRecordingJob(discussionId, input) {
+	const inputJson = JSON.stringify({
+		chunkCount: input.chunkCount,
+		mimeType: input.mimeType,
+		fileName: input.fileName,
+		lastSequence: input.lastSequence,
+		...input.containerMode ? { containerMode: input.containerMode } : {}
+	});
+	return runSqliteWriteTransaction((db) => {
+		const chunks = listRecordingChunks(discussionId);
+		const manifestHash = createHash("sha256").update(inputJson).update(JSON.stringify(chunks)).digest("hex");
+		const existing = db.prepare("SELECT * FROM discussion_recording_jobs WHERE discussion_id=?").get(discussionId);
+		if (existing && existing.input_json !== inputJson) throw new DiscussionServiceError("conflict", "Recording manifest differs from the submitted recording");
+		if (existing && chunks.length && existing.manifest_hash !== manifestHash) throw new DiscussionServiceError("conflict", "Recording contents differ from the submitted manifest");
+		if (existing?.state === "cancelled") throw new DiscussionServiceError("conflict", "Recording job was cancelled");
+		if (existing?.state === "failed") db.prepare("UPDATE discussion_recording_jobs SET state='queued', error=NULL, updated_at=? WHERE id=?").run(Date.now(), existing.id);
+		if (!existing) db.prepare("INSERT INTO discussion_recording_jobs (id, discussion_id, input_json, manifest_hash, state, created_at, updated_at) VALUES (?, ?, ?, ?, 'queued', ?, ?)").run(randomUUID(), discussionId, inputJson, manifestHash, Date.now(), Date.now());
+		return getRecordingJob(discussionId);
+	});
+}
+function claimRecordingJob(owner, now = Date.now()) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT j.* FROM discussion_recording_jobs j JOIN discussion_captures d ON d.id=j.discussion_id
+      WHERE (j.state='queued' OR (j.state='running' AND j.lease_until<=?))
+      AND (d.status IN ('recording','stopping','needs_attention') OR d.audio_attachment_id IS NOT NULL)
+      AND d.status<>'cancelled' AND d.audio_deleted_at IS NULL
+      ORDER BY j.created_at LIMIT 1`).get(now);
+		if (!row) return null;
+		db.prepare("UPDATE discussion_recording_jobs SET state='running', lease_owner=?, lease_until=?, updated_at=? WHERE id=?").run(owner, now + LEASE_MS, now, row.id);
+		return {
+			...mapJob(row),
+			input: JSON.parse(row.input_json)
+		};
+	});
+}
+function renewRecordingJob(id, owner, now = Date.now()) {
+	return getSqliteDatabase().prepare("UPDATE discussion_recording_jobs SET lease_until=? WHERE id=? AND state='running' AND lease_owner=? AND lease_until>?").run(now + LEASE_MS, id, owner, now).changes === 1;
+}
+function finishRecordingJob(id, owner, error) {
+	return getSqliteDatabase().prepare(`UPDATE discussion_recording_jobs SET state=?, error=?, lease_owner=NULL, lease_until=NULL, updated_at=?
+    WHERE id=? AND state='running' AND lease_owner=? AND lease_until>?`).run(error === void 0 ? "completed" : "failed", error?.slice(0, 1e3) ?? null, Date.now(), id, owner, Date.now()).changes === 1;
+}
+function cancelRecordingJob(discussionId) {
+	getSqliteDatabase().prepare("UPDATE discussion_recording_jobs SET state='cancelled', lease_owner=NULL, lease_until=NULL, updated_at=? WHERE discussion_id=? AND state<>'completed'").run(Date.now(), discussionId);
+}
+//#endregion
+export { cancelRecordingJob, claimRecordingJob, finishRecordingJob, getRecordingJob, getRecordingJobInput, renewRecordingJob, submitRecordingJob };

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

@@ -10,7 +10,7 @@ export declare function listDiscussionCaptures(query?: ListDiscussionsQuery): Di
 export declare function getDiscussionMetrics(): DiscussionMetrics;
 export declare function updateDiscussionCapture(id: string, patch: Partial<Omit<DiscussionCapture, 'id' | 'clientRequestId' | 'noteId' | 'createdAt'>>, expectedStatuses?: DiscussionStatus[]): DiscussionCapture | null;
 export declare function claimNextDiscussionCapture(owner: string, now?: number, leaseMs?: number): DiscussionCapture | null;
-export declare function releaseDiscussionWorkLease(id: string): void;
+export declare function releaseDiscussionWorkLease(id: string, owner: string): void;
 export declare function createDiscussionTranscriptSegment(input: {
     discussionId: string;
     sequence: number;
@@ -24,7 +24,7 @@ export declare function getDiscussionTranscriptSegment(discussionId: string, seq
 export declare function listDiscussionTranscriptSegments(discussionId: string): DiscussionTranscriptSegment[];
 export declare function claimNextDiscussionTranscriptSegment(owner: string, now?: number, leaseMs?: number): ClaimedDiscussionTranscriptSegment | null;
 export declare function completeDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, text: string, provider: string, language?: string, confidence?: number): DiscussionTranscriptSegment | null;
-export declare function correctDiscussionTranscriptSegment(discussionId: string, sequence: number, displayText: string, expectedRevision: number): DiscussionTranscriptSegment | null;
+export declare function correctDiscussionTranscriptSegment(discussionId: string, sequence: number, displayText: string, expectedRevision: number, speakerLabel?: string): DiscussionTranscriptSegment | null;
 export declare function retryOrFailDiscussionTranscriptSegment(discussionId: string, sequence: number, owner: string, error: string, exhausted: boolean): DiscussionTranscriptSegment | null;
 export declare function deleteDiscussionSegmentAudio(discussionId: string): void;
 export declare function createDiscussionOrganization(input: {
@@ -32,9 +32,11 @@ export declare function createDiscussionOrganization(input: {
     inputTranscriptSha256: string;
     promptVersion: string;
     modelRef: string;
+    transcriptRevision: number;
 }): DiscussionOrganizationRecord;
 export declare function getLatestDiscussionOrganization(discussionId: string): DiscussionOrganizationRecord | null;
 export declare function completeDiscussionOrganization(id: string, organization: DiscussionOrganization): DiscussionOrganizationRecord | null;
 export declare function failDiscussionOrganization(id: string, error: string): void;
 export declare function getDiscussionCaptureSettings(): DiscussionCaptureSettings;
 export declare function acknowledgeDiscussionCaptureConsent(policyVersion: number): DiscussionCaptureSettings;
+export declare function renewDiscussionWorkLease(id: string, owner: string): boolean;

package/dist/src/discussions/repository.js

@@ -1,5 +1,5 @@
 import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
-import { DISCUSSION_STATUSES } from "./types.js";
+import { DISCUSSION_STATUSES } from "../../packages/gateway-contract/src/discussions.js";
 import { randomUUID } from "node:crypto";
 //#region src/discussions/repository.ts
 function optional(condition, value) {
@@ -17,6 +17,7 @@ function discussionFromRow(row) {
 		createdAt: row.created_at,
 		updatedAt: row.updated_at
 	};
+	capture.template = row.organization_template;
 	if (row.project_id) capture.projectId = row.project_id;
 	if (row.audio_attachment_id) capture.audioAttachmentId = row.audio_attachment_id;
 	if (row.duration_ms != null) capture.durationMs = row.duration_ms;
@@ -71,6 +72,7 @@ function organizationFromRow(row) {
 		revision: row.revision,
 		inputTranscriptSha256: row.input_transcript_sha256,
 		promptVersion: row.prompt_version,
+		transcriptRevision: row.transcript_revision,
 		modelRef: row.model_ref,
 		...optional(row.organization_json, { organization: JSON.parse(row.organization_json) }),
 		status: row.status,
@@ -161,7 +163,7 @@ function updateDiscussionCapture(id, patch, expectedStatuses) {
     mime_type=?, audio_size_bytes=?, audio_sha256=?, canonical_transcript=?, canonical_transcript_sha256=?,
     transcript_language=?, transcript_revision=?, generated_title=?, project_inference_score=?,
     project_inference_source=?, failure_stage=?, failure_code=?, failure_message=?, recording_started_at=?,
-    recording_stopped_at=?, updated_at=?, completed_at=?, audio_deleted_at=? WHERE id=?${statusGuard}`).run(next.projectId ?? null, next.audioAttachmentId ?? null, next.source, next.status, next.durationMs ?? null, next.expectedLastSequence ?? null, next.mimeType ?? null, next.audioSizeBytes ?? null, next.audioSha256 ?? null, next.canonicalTranscript ?? null, next.canonicalTranscriptSha256 ?? null, next.transcriptLanguage ?? null, next.transcriptRevision, next.generatedTitle ?? null, next.projectInferenceScore ?? null, next.projectInferenceSource ?? null, next.failureStage ?? null, next.failureCode ?? null, next.failureMessage ?? null, next.recordingStartedAt, next.recordingStoppedAt ?? null, next.updatedAt, next.completedAt ?? null, next.audioDeletedAt ?? null, id, ...expectedStatuses ?? []).changes) ? getDiscussionCapture(id) : null;
+    recording_stopped_at=?, updated_at=?, completed_at=?, audio_deleted_at=?, organization_template=? WHERE id=?${statusGuard}`).run(next.projectId ?? null, next.audioAttachmentId ?? null, next.source, next.status, next.durationMs ?? null, next.expectedLastSequence ?? null, next.mimeType ?? null, next.audioSizeBytes ?? null, next.audioSha256 ?? null, next.canonicalTranscript ?? null, next.canonicalTranscriptSha256 ?? null, next.transcriptLanguage ?? null, next.transcriptRevision, next.generatedTitle ?? null, next.projectInferenceScore ?? null, next.projectInferenceSource ?? null, next.failureStage ?? null, next.failureCode ?? null, next.failureMessage ?? null, next.recordingStartedAt, next.recordingStoppedAt ?? null, next.updatedAt, next.completedAt ?? null, next.audioDeletedAt ?? null, next.template ?? "general", id, ...expectedStatuses ?? []).changes) ? getDiscussionCapture(id) : null;
 }
 function claimNextDiscussionCapture(owner, now = Date.now(), leaseMs = 5 * 6e4) {
 	return runSqliteWriteTransaction((db) => {
@@ -173,8 +175,8 @@ function claimNextDiscussionCapture(owner, now = Date.now(), leaseMs = 5 * 6e4)
       WHERE id=? AND status='organizing' AND (work_lease_owner IS NULL OR work_lease_expires_at <= ?)`).run(owner, now + leaseMs, now, row.id, now).changes ? getDiscussionCapture(row.id) : null;
 	});
 }
-function releaseDiscussionWorkLease(id) {
-	runSqliteWriteTransaction((db) => db.prepare("UPDATE discussion_captures SET work_lease_owner=NULL, work_lease_expires_at=NULL WHERE id=?").run(id));
+function releaseDiscussionWorkLease(id, owner) {
+	runSqliteWriteTransaction((db) => db.prepare("UPDATE discussion_captures SET work_lease_owner=NULL, work_lease_expires_at=NULL WHERE id=? AND work_lease_owner=?").run(id, owner));
 }
 function createDiscussionTranscriptSegment(input) {
 	const existing = getDiscussionTranscriptSegment(input.discussionId, input.sequence);
@@ -228,12 +230,12 @@ function completeDiscussionTranscriptSegment(discussionId, sequence, owner, text
 		return changed;
 	}) ? getDiscussionTranscriptSegment(discussionId, sequence) : null;
 }
-function correctDiscussionTranscriptSegment(discussionId, sequence, displayText, expectedRevision) {
+function correctDiscussionTranscriptSegment(discussionId, sequence, displayText, expectedRevision, speakerLabel) {
 	const now = Date.now();
 	return runSqliteWriteTransaction((db) => {
-		const changed = db.prepare(`UPDATE discussion_transcript_segments SET display_text=?, corrected_by_user=1,
+		const changed = db.prepare(`UPDATE discussion_transcript_segments SET display_text=?, speaker_label=CASE WHEN ? THEN ? ELSE speaker_label END, corrected_by_user=1,
       corrected_at=?, revision=revision+1, updated_at=? WHERE discussion_id=? AND sequence=?
-      AND status='confirmed' AND revision=?`).run(displayText, now, now, discussionId, sequence, expectedRevision).changes;
+      AND status='confirmed' AND revision=?`).run(displayText, speakerLabel === void 0 ? 0 : 1, speakerLabel?.trim() || null, now, now, discussionId, sequence, expectedRevision).changes;
 		if (changed) db.prepare("UPDATE discussion_captures SET transcript_revision=transcript_revision+1, updated_at=? WHERE id=?").run(now, discussionId);
 		return changed;
 	}) ? getDiscussionTranscriptSegment(discussionId, sequence) : null;
@@ -253,8 +255,8 @@ function createDiscussionOrganization(input) {
 	const revision = (getLatestDiscussionOrganization(input.discussionId)?.revision ?? 0) + 1;
 	const id = randomUUID();
 	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO discussion_organizations (
-    id, discussion_id, revision, input_transcript_sha256, prompt_version, model_ref, status, created_at
-  ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?)`).run(id, input.discussionId, revision, input.inputTranscriptSha256, input.promptVersion, input.modelRef, now));
+    id, discussion_id, revision, input_transcript_sha256, prompt_version, model_ref, transcript_revision, status, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, 'running', ?)`).run(id, input.discussionId, revision, input.inputTranscriptSha256, input.promptVersion, input.modelRef, input.transcriptRevision, now));
 	return getLatestDiscussionOrganization(input.discussionId);
 }
 function getLatestDiscussionOrganization(discussionId) {
@@ -285,5 +287,8 @@ function acknowledgeDiscussionCaptureConsent(policyVersion) {
     SET consent_acknowledged_at=?, updated_at=? WHERE workspace_id='default' AND consent_policy_version=?`).run(now, now, policyVersion));
 	return getDiscussionCaptureSettings();
 }
+function renewDiscussionWorkLease(id, owner) {
+	return Number(getSqliteDatabase().prepare("UPDATE discussion_captures SET work_lease_expires_at=? WHERE id=? AND work_lease_owner=? AND status='organizing'").run(Date.now() + 5 * 6e4, id, owner).changes) === 1;
+}
 //#endregion
-export { acknowledgeDiscussionCaptureConsent, claimNextDiscussionCapture, claimNextDiscussionTranscriptSegment, completeDiscussionOrganization, completeDiscussionTranscriptSegment, correctDiscussionTranscriptSegment, createDiscussionCapture, createDiscussionOrganization, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, failDiscussionOrganization, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, getLatestDiscussionOrganization, listDiscussionCaptures, listDiscussionTranscriptSegments, releaseDiscussionWorkLease, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture };
+export { acknowledgeDiscussionCaptureConsent, claimNextDiscussionCapture, claimNextDiscussionTranscriptSegment, completeDiscussionOrganization, completeDiscussionTranscriptSegment, correctDiscussionTranscriptSegment, createDiscussionCapture, createDiscussionOrganization, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, failDiscussionOrganization, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, getLatestDiscussionOrganization, listDiscussionCaptures, listDiscussionTranscriptSegments, releaseDiscussionWorkLease, renewDiscussionWorkLease, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture };

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

@@ -0,0 +1,12 @@
+import type { DiscussionTranscriptSegment } from './types.js';
+export declare function saveTranscriptRevision(id: string): number;
+export declare function readTranscriptRevision(id: string, revision: number): DiscussionTranscriptSegment[] | null;
+export declare function replaceTranscriptSegments(id: string, segments: Array<{
+    text: string;
+    startedAtMs: number;
+    endedAtMs: number;
+    speakerLabel?: string;
+    correctedByUser?: boolean;
+    rawText?: string;
+}>): void;
+export declare function refreshCanonicalTranscript(id: string): void;

package/dist/src/discussions/revisions.js

@@ -0,0 +1,36 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getDiscussionCapture, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
+import { assembleDiscussionTranscript } from "./transcript.js";
+import { createHash } from "node:crypto";
+//#region src/discussions/revisions.ts
+function saveTranscriptRevision(id) {
+	const capture = getDiscussionCapture(id);
+	if (!capture) throw new Error("Discussion not found");
+	getSqliteDatabase().prepare("INSERT OR IGNORE INTO discussion_transcript_revisions (discussion_id, revision, segments_json, created_at) VALUES (?, ?, ?, ?)").run(id, capture.transcriptRevision, JSON.stringify(listDiscussionTranscriptSegments(id)), Date.now());
+	return capture.transcriptRevision;
+}
+function readTranscriptRevision(id, revision) {
+	const row = getSqliteDatabase().prepare("SELECT segments_json FROM discussion_transcript_revisions WHERE discussion_id=? AND revision=?").get(id, revision);
+	return row ? JSON.parse(row.segments_json) : null;
+}
+function replaceTranscriptSegments(id, segments) {
+	runSqliteWriteTransaction((db) => {
+		saveTranscriptRevision(id);
+		db.prepare("DELETE FROM discussion_transcript_segments WHERE discussion_id=?").run(id);
+		const insert = db.prepare(`INSERT INTO discussion_transcript_segments
+      (discussion_id, sequence, audio_sha256, started_at_ms, ended_at_ms, status, raw_text, display_text, speaker_label, revision, corrected_by_user, attempt_count, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, 'confirmed', ?, ?, ?, 1, ?, 0, ?, ?)`);
+		segments.forEach((segment, index) => insert.run(id, index, createHash("sha256").update(segment.text).digest("hex"), segment.startedAtMs, segment.endedAtMs, segment.rawText ?? segment.text, segment.text, segment.speakerLabel ?? null, segment.correctedByUser ? 1 : 0, Date.now(), Date.now()));
+		db.prepare("UPDATE discussion_captures SET transcript_revision=transcript_revision+1 WHERE id=?").run(id);
+		saveTranscriptRevision(id);
+	});
+}
+function refreshCanonicalTranscript(id) {
+	const text = assembleDiscussionTranscript(listDiscussionTranscriptSegments(id));
+	updateDiscussionCapture(id, {
+		canonicalTranscript: text,
+		canonicalTranscriptSha256: createHash("sha256").update(text).digest("hex")
+	});
+}
+//#endregion
+export { readTranscriptRevision, refreshCanonicalTranscript, replaceTranscriptSegments, saveTranscriptRevision };

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

@@ -2,6 +2,7 @@ import type { Config } from '../config/schema.js';
 import type { NotesService } from '../notes/service.js';
 import type { DiscussionCapture } from './types.js';
 export interface DiscussionSealerDeps {
+    processRecordingJob?: () => Promise<void>;
     notes: NotesService;
     getConfig: () => Config;
     transcribeRecording?: (filePath: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{

package/dist/src/discussions/sealer.js

@@ -1,12 +1,16 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { decodeWavToMonoFloat32 } from "../voice/local/wav.js";
 import { forEachNormalizedAudioSegment } from "../voice/audio/normalize.js";
-import { isSTTAvailable } from "../voice/stt/availability.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 { appendSequentialTranscript, assembleDiscussionTranscript } from "./transcript.js";
+import { assembleDiscussionTranscript } from "./transcript.js";
+import { replaceTranscriptSegments, saveTranscriptRevision } from "./revisions.js";
+import { missingAudioRanges, slicePcmWav } from "./audio-repair.js";
+import { getRecordingJob } from "./recordingJobs.js";
 import { createHash } from "node:crypto";
 //#region src/discussions/sealer.ts
 init_logger();
@@ -34,6 +38,7 @@ var DiscussionSealer = class {
 		if (this.running) return;
 		this.running = true;
 		try {
+			await this.deps.processRecordingJob?.();
 			const capture = [...listDiscussionCaptures({
 				status: "sealing",
 				limit: 1
@@ -50,6 +55,8 @@ var DiscussionSealer = class {
 	async sealWhenReady(capture, now) {
 		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");
 			return;
 		}
@@ -65,6 +72,7 @@ var DiscussionSealer = class {
 			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 text = result.text.trim();
+			saveTranscriptRevision(capture.id);
 			if (!text) throw new Error("Discussion transcription produced no text");
 			const updated = updateDiscussionCapture(capture.id, {
 				status: "organizing",
@@ -85,22 +93,64 @@ var DiscussionSealer = class {
 	async transcribeFullRecording(capture) {
 		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
 		if (!attachment) throw new Error("Discussion audio file is missing");
-		if (this.deps.transcribeRecording) return this.deps.transcribeRecording(attachment.filePath, capture);
+		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;
+		}
 		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 text = "";
+		let offset = 0;
+		const confirmed = listDiscussionTranscriptSegments(capture.id).filter((segment) => segment.status === "confirmed");
+		const segments = confirmed.map((segment) => ({
+			text: segment.displayText ?? segment.rawText ?? "",
+			rawText: segment.rawText,
+			startedAtMs: segment.startedAtMs,
+			endedAtMs: segment.endedAtMs,
+			speakerLabel: segment.speakerLabel,
+			correctedByUser: segment.correctedByUser
+		}));
 		let language;
-		await forEachNormalizedAudioSegment({ filePath: attachment.filePath }, async (buffer, index) => {
-			const result = await transcribe(buffer, sttConfig, {
-				mime: "audio/wav",
-				fileName: `discussion-recovery-${index}.wav`
-			});
-			text = appendSequentialTranscript(text, result.text);
-			language ??= result.language;
+		await forEachNormalizedAudioSegment({
+			filePath: attachment.filePath,
+			maxDurationSeconds: 7200
+		}, async (buffer, index) => {
+			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}` } : {}
+					});
+				}
+				else if (result.text.trim()) segments.push({
+					text: result.text,
+					...gap
+				});
+				language ??= result.language;
+			}
+			offset += durationMs;
 		});
+		segments.sort((a, b) => a.startedAtMs - b.startedAtMs);
+		replaceTranscriptSegments(capture.id, segments);
 		return {
-			text,
+			text: assembleDiscussionTranscript(listDiscussionTranscriptSegments(capture.id)),
 			...language ? { language } : {}
 		};
 	}