@xopcai/xopc 0.0.277 → 0.0.282

package/dist/src/discussions/export.js

@@ -0,0 +1,23 @@
+import { DiscussionServiceError } from "./errors.js";
+//#region src/discussions/export.ts
+const time = (ms) => `${String(Math.floor(ms / 36e5)).padStart(2, "0")}:${String(Math.floor(ms / 6e4) % 60).padStart(2, "0")}:${String(Math.floor(ms / 1e3) % 60).padStart(2, "0")},${String(Math.round(ms) % 1e3).padStart(3, "0")}`;
+function exportDiscussion(detail, format) {
+	const segments = detail.transcript.segments.filter((segment) => segment.status === "confirmed");
+	if (format === "txt") return segments.map((segment) => `${time(segment.startedAtMs)} ${segment.speakerLabel ?? ""}\n${segment.displayText ?? segment.rawText ?? ""}`).join("\n\n");
+	if (format === "srt") return segments.map((segment, index) => `${index + 1}\n${time(segment.startedAtMs)} --> ${time(segment.endedAtMs)}\n${segment.speakerLabel ? `${segment.speakerLabel}: ` : ""}${segment.displayText ?? segment.rawText ?? ""}`).join("\n\n");
+	if (format !== "md") throw new DiscussionServiceError("invalid_input", "Unsupported export format");
+	const organization = detail.organization?.organization;
+	if (!organization) throw new DiscussionServiceError("conflict", "Meeting summary is not ready");
+	return [
+		`# ${organization.title}`,
+		organization.summary,
+		...[
+			["Decisions", organization.decisions.filter((item) => !item.ignored && !item.supersededBy).map((item) => item.text)],
+			["Actions", organization.actionItems.filter((item) => !item.ignored && !item.supersededBy).map((item) => `${item.title}${item.owner ? ` · ${item.owner}` : ""}${item.dueDate ? ` · ${item.dueDate}` : ""}`)],
+			["Risks", organization.risks.filter((item) => !item.ignored && !item.supersededBy).map((item) => item.text)],
+			["Open questions", organization.openQuestions.filter((item) => !item.ignored && !item.supersededBy).map((item) => item.text)]
+		].map(([title, items]) => `## ${title}\n\n${items.map((text) => `- ${text}`).join("\n")}`)
+	].join("\n\n");
+}
+//#endregion
+export { exportDiscussion };

package/dist/src/discussions/index.js

@@ -1,6 +1,7 @@
+import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_STATUSES } from "../../packages/gateway-contract/src/discussions.js";
+import { DiscussionServiceError } from "./errors.js";
 import { analyzeDiscussion } from "./analyzer.js";
-import { DISCUSSION_STATUSES } from "./types.js";
-import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DiscussionService, DiscussionServiceError } from "./service.js";
+import { DiscussionService } from "./service.js";
 import { DiscussionOrganizer } from "./organizer.js";
 import { DiscussionLiveWorker } from "./live-worker.js";
 import { DiscussionOrganizerWorker } from "./organizer-worker.js";

package/dist/src/discussions/live-worker.js

@@ -5,9 +5,9 @@ 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 { enrichLiveDiscussion } from "./analyzer.js";
 import { claimNextDiscussionTranscriptSegment, completeDiscussionTranscriptSegment, getDiscussionCapture, listDiscussionTranscriptSegments, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture } from "./repository.js";
 import { assembleDiscussionTranscript } from "./transcript.js";
+import { enrichLiveDiscussion } from "./analyzer.js";
 import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
 import { randomUUID } from "node:crypto";
 //#region src/discussions/live-worker.ts

package/dist/src/discussions/organizer-worker.js

@@ -1,6 +1,6 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { claimNextDiscussionCapture, getDiscussionCapture, releaseDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
+import { claimNextDiscussionCapture, getDiscussionCapture, releaseDiscussionWorkLease, renewDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
 import { randomUUID } from "node:crypto";
 //#region src/discussions/organizer-worker.ts
 init_logger();
@@ -31,13 +31,20 @@ var DiscussionOrganizerWorker = class {
 		try {
 			const capture = claimNextDiscussionCapture(this.owner);
 			if (!capture) return;
+			const controller = new AbortController();
+			const renewal = setInterval(() => {
+				if (!renewDiscussionWorkLease(capture.id, this.owner)) controller.abort();
+			}, 3e4);
+			renewal.unref();
 			try {
-				await this.processor.process(capture, this.owner);
-				releaseDiscussionWorkLease(capture.id);
+				await this.processor.process(capture, this.owner, controller.signal);
+				releaseDiscussionWorkLease(capture.id, this.owner);
 			} catch (error) {
 				const message = error instanceof Error ? error.message : String(error);
-				releaseDiscussionWorkLease(capture.id);
-				const updated = getDiscussionCapture(capture.id) && updateDiscussionCapture(capture.id, {
+				const ownsLease = renewDiscussionWorkLease(capture.id, this.owner);
+				releaseDiscussionWorkLease(capture.id, this.owner);
+				const current = getDiscussionCapture(capture.id);
+				const updated = ownsLease && current && updateDiscussionCapture(capture.id, {
 					status: "needs_attention",
 					failureStage: "organization",
 					failureCode: "organization_failed",
@@ -48,6 +55,8 @@ var DiscussionOrganizerWorker = class {
 					err: error,
 					discussionId: capture.id
 				}, `Discussion organization failed: ${message}`);
+			} finally {
+				clearInterval(renewal);
 			}
 		} finally {
 			this.running = false;

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

@@ -17,6 +17,6 @@ export declare class DiscussionOrganizer {
     private readonly deps;
     private readonly objectLinks;
     constructor(deps: DiscussionOrganizerDeps);
-    process(capture: DiscussionCapture, _owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
+    process(capture: DiscussionCapture, owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
     private linkProject;
 }

package/dist/src/discussions/organizer.js

@@ -1,18 +1,22 @@
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
 import { ObjectLinkService } from "../activity/service.js";
+import { completeDiscussionOrganization, createDiscussionOrganization, getDiscussionCapture, getLatestDiscussionOrganization, listDiscussionTranscriptSegments, renewDiscussionWorkLease, updateDiscussionCapture } from "./repository.js";
+import { saveTranscriptRevision } from "./revisions.js";
 import { analyzeDiscussion } from "./analyzer.js";
-import { completeDiscussionOrganization, createDiscussionOrganization, updateDiscussionCapture } from "./repository.js";
+import { applyMeetingEdits } from "./edits.js";
 import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
 //#region src/discussions/organizer.ts
-const PROMPT_VERSION = "discussion-organizer-v1";
+const PROMPT_VERSION = "discussion-evidence-v2";
 var DiscussionOrganizer = class {
 	objectLinks = new ObjectLinkService();
 	constructor(deps) {
 		this.deps = deps;
 	}
-	async process(capture, _owner, signal) {
+	async process(capture, owner, signal) {
 		const transcript = capture.canonicalTranscript?.trim();
 		const inputHash = capture.canonicalTranscriptSha256;
 		if (!transcript || !inputHash) throw new Error("Canonical discussion transcript is missing");
+		const transcriptRevision = saveTranscriptRevision(capture.id);
 		const projects = this.deps.projects.list({
 			status: "active",
 			limit: 100
@@ -20,18 +24,35 @@ var DiscussionOrganizer = class {
 		const result = this.deps.organizeTranscript ? await this.deps.organizeTranscript(transcript, capture, signal) : await analyzeDiscussion({
 			config: this.deps.getConfig(),
 			transcript,
+			segments: listDiscussionTranscriptSegments(capture.id),
+			discussionId: capture.id,
+			template: capture.template,
 			projects: projects.map(({ id, name }) => ({
 				id,
 				name
 			})),
 			signal
 		});
-		completeDiscussionOrganization(createDiscussionOrganization({
-			discussionId: capture.id,
-			inputTranscriptSha256: inputHash,
-			promptVersion: PROMPT_VERSION,
-			modelRef: result.modelRef
-		}).id, result.organization);
+		signal?.throwIfAborted();
+		if (!renewDiscussionWorkLease(capture.id, owner)) throw new Error("Meeting processing lease lost");
+		if (getDiscussionCapture(capture.id)?.canonicalTranscriptSha256 !== inputHash) throw new Error("Transcript changed during organization");
+		const previous = getLatestDiscussionOrganization(capture.id)?.organization;
+		if (previous) {
+			const signature = (refs) => JSON.stringify([...refs].sort((a, b) => a - b));
+			for (const kind of [
+				"decisions",
+				"actionItems",
+				"risks",
+				"openQuestions"
+			]) for (const item of result.organization[kind]) {
+				const candidates = previous[kind].filter((old) => signature(old.evidenceSegmentIds) === signature(item.evidenceSegmentIds));
+				const label = (value) => "title" in value ? value.title : value.text;
+				const exact = previous[kind].filter((old) => label(old) === label(item));
+				const matches = exact.length ? exact : candidates;
+				const currentMatches = result.organization[kind].filter((other) => signature(other.evidenceSegmentIds) === signature(item.evidenceSegmentIds));
+				if (matches.length === 1 && (label(matches[0]) === label(item) && result.organization[kind].filter((other) => label(other) === label(item)).length === 1 || currentMatches.length === 1)) item.id = matches[0].id;
+			}
+		}
 		let inferredProject;
 		if (!capture.projectId) {
 			const exact = findExactProjectMention(transcript, projects);
@@ -50,23 +71,38 @@ var DiscussionOrganizer = class {
 		if (!note) throw new Error("Discussion note is missing");
 		const title = result.organization.title.trim().slice(0, 200);
 		if (note.title?.startsWith("Discussion ·") && title) await this.deps.notes.updateNote(capture.noteId, { title }, "ai_edit");
-		const updated = updateDiscussionCapture(capture.id, {
-			status: "completed",
-			generatedTitle: title,
-			...inferredProject ? {
-				projectId: inferredProject.id,
-				projectInferenceScore: inferredProject.score,
-				projectInferenceSource: inferredProject.source
-			} : {},
-			failureStage: void 0,
-			failureCode: void 0,
-			failureMessage: void 0,
-			completedAt: Date.now()
-		}, ["organizing"]);
-		if (!updated) throw new Error("Discussion changed while applying organization");
+		const updated = runSqliteWriteTransaction(() => {
+			signal?.throwIfAborted();
+			if (!renewDiscussionWorkLease(capture.id, owner)) throw new Error("Meeting processing lease lost");
+			if (getDiscussionCapture(capture.id)?.canonicalTranscriptSha256 !== inputHash) throw new Error("Transcript changed during organization");
+			const record = createDiscussionOrganization({
+				discussionId: capture.id,
+				transcriptRevision,
+				inputTranscriptSha256: inputHash,
+				promptVersion: PROMPT_VERSION,
+				modelRef: result.modelRef
+			});
+			result.organization = applyMeetingEdits(capture.id, result.organization);
+			completeDiscussionOrganization(record.id, result.organization);
+			const published = updateDiscussionCapture(capture.id, {
+				status: "completed",
+				generatedTitle: title,
+				...inferredProject ? {
+					projectId: inferredProject.id,
+					projectInferenceScore: inferredProject.score,
+					projectInferenceSource: inferredProject.source
+				} : {},
+				failureStage: void 0,
+				failureCode: void 0,
+				failureMessage: void 0,
+				completedAt: capture.completedAt ?? Date.now()
+			}, ["organizing"]);
+			if (!published) throw new Error("Discussion changed while applying organization");
+			return published;
+		});
 		if (inferredProject) this.linkProject(updated, inferredProject.id);
 		this.deps.onUpdated?.(updated);
-		this.deps.onCompleted?.(updated, result.organization);
+		if (!capture.completedAt) this.deps.onCompleted?.(updated, result.organization);
 		return updated;
 	}
 	linkProject(capture, projectId) {

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

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import type { DiscussionOrganization } from './types.js';
+type Candidate = {
+    id: string;
+    kind: string;
+    text: string;
+    evidenceSegmentIds: number[];
+};
+export declare const MeetingChangesSchema: z.ZodObject<{
+    changes: z.ZodArray<z.ZodObject<{
+        fromId: z.ZodString;
+        toId: z.ZodString;
+        relation: z.ZodEnum<{
+            supersedes: "supersedes";
+            contradicts: "contradicts";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type MeetingChange = z.infer<typeof MeetingChangesSchema>['changes'][number];
+/** Relations can only point from an earlier fact to an actual later fact. */
+export declare function reconcileMeetingChapters(chapters: DiscussionOrganization[], compare: (earlier: Candidate[], later: Candidate[]) => Promise<MeetingChange[]>): Promise<MeetingChange[]>;
+export {};

package/dist/src/discussions/reconcile.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+//#region src/discussions/reconcile.ts
+const MeetingChangesSchema = z.object({ changes: z.array(z.object({
+	fromId: z.string(),
+	toId: z.string(),
+	relation: z.enum(["supersedes", "contradicts"])
+})).max(200) });
+function groups(items) {
+	const result = [];
+	let current = [];
+	let size = 0;
+	for (const item of items) {
+		const length = JSON.stringify(item).length;
+		if (length > 12e3) throw new Error("Meeting fact exceeds reconciliation input budget");
+		if (current.length && size + length > 12e3) {
+			result.push(current);
+			current = [];
+			size = 0;
+		}
+		current.push(item);
+		size += length;
+	}
+	if (current.length) result.push(current);
+	return result;
+}
+/** Relations can only point from an earlier fact to an actual later fact. */
+async function reconcileMeetingChapters(chapters, compare) {
+	const earlier = [];
+	const changes = /* @__PURE__ */ new Map();
+	for (const chapter of chapters) {
+		const later = [];
+		for (const kind of [
+			"decisions",
+			"actionItems",
+			"risks",
+			"openQuestions"
+		]) for (const item of chapter[kind]) later.push({
+			id: item.id,
+			kind,
+			text: "title" in item ? item.title : item.text,
+			evidenceSegmentIds: item.evidenceSegmentIds
+		});
+		for (const left of groups(earlier)) for (const right of groups(later)) {
+			const output = await compare(left, right);
+			for (const change of output) {
+				if (change.fromId === change.toId || !left.some((item) => item.id === change.fromId) || !right.some((item) => item.id === change.toId)) throw new Error("Meeting change refers to an invalid or unordered fact");
+				changes.set(`${change.fromId}:${change.toId}`, change);
+			}
+		}
+		earlier.push(...later.filter((item) => item.kind === "decisions" || item.kind === "actionItems"));
+	}
+	return [...changes.values()];
+}
+//#endregion
+export { MeetingChangesSchema, reconcileMeetingChapters };

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

@@ -0,0 +1,9 @@
+import { type DiscussionRecordingChunk, type DiscussionRecordingManifest } from '@xopcai/gateway-contract';
+import type { NotesService } from '../notes/service.js';
+import type { DiscussionCapture } from './types.js';
+export declare function listRecordingChunks(id: string): DiscussionRecordingChunk[];
+/** Called under the discussion mutation queue. Receipt follows durable disk write. */
+export declare function saveRecordingChunk(capture: DiscussionCapture, sequence: number, sha256: string, body: ReadableStream<Uint8Array>): Promise<DiscussionRecordingChunk>;
+export declare function validateRecordingManifest(capture: DiscussionCapture, input: DiscussionRecordingManifest): void;
+export declare function completeRecording(capture: DiscussionCapture, input: DiscussionRecordingManifest, notes: NotesService, assertLease: () => void, signal: AbortSignal): Promise<DiscussionCapture>;
+export declare function removeRecordingChunks(capture: DiscussionCapture): Promise<void>;

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;