@xopcai/xopc 0.0.277 → 0.0.282

package/dist/src/discussions/service.js

@@ -1,34 +1,28 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_SEGMENT_MAX_BYTES } from "../../packages/gateway-contract/src/discussions.js";
 import { ObjectLinkService } from "../activity/service.js";
+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 { editMeeting } from "./edits.js";
+import { completeRecording, listRecordingChunks, removeRecordingChunks, saveRecordingChunk, validateRecordingManifest } from "./recording.js";
+import { cancelRecordingJob, claimRecordingJob, finishRecordingJob, getRecordingJob, getRecordingJobInput, renewRecordingJob, submitRecordingJob } from "./recordingJobs.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/discussions/service.ts
 init_logger();
 const log = createLogger("DiscussionService");
-const DISCUSSION_AUDIO_MAX_BYTES = 25 * 1024 * 1024;
-const DISCUSSION_SEGMENT_MAX_BYTES = 2 * 1024 * 1024;
-const DISCUSSION_MAX_DURATION_MS = 1800 * 1e3;
-function isSupportedAudioMimeType(mimeType) {
-	const base = mimeType.toLowerCase().split(";", 1)[0]?.trim();
-	return base === "audio/webm" || base === "audio/mp4" || base === "audio/ogg" || base === "audio/wav" || base === "audio/x-wav" || base === "audio/mpeg";
-}
 function placeholderTitle(now) {
 	return `Discussion · ${new Date(now).toISOString().slice(0, 16).replace("T", " ")}`;
 }
-var DiscussionServiceError = class extends Error {
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "DiscussionServiceError";
-	}
-};
 var DiscussionService = class {
 	createsInFlight = /* @__PURE__ */ new Map();
 	mutationTails = /* @__PURE__ */ new Map();
 	objectLinks = new ObjectLinkService();
+	recordingOwner = randomUUID();
+	recordingControllers = /* @__PURE__ */ new Map();
 	constructor(notes, projects, emit) {
 		this.notes = notes;
 		this.projects = projects;
@@ -42,6 +36,7 @@ var DiscussionService = class {
 		return acknowledgeDiscussionCaptureConsent(policyVersion);
 	}
 	async create(input) {
+		if (input.recordedAt !== void 0 && (!Number.isSafeInteger(input.recordedAt) || input.recordedAt < 0 || input.recordedAt > Date.now() + 6e4)) throw new DiscussionServiceError("invalid_input", "Invalid recording time");
 		const clientRequestId = input.clientRequestId.trim();
 		if (!clientRequestId || clientRequestId.length > 200) throw new DiscussionServiceError("invalid_input", "clientRequestId must be between 1 and 200 characters");
 		const settings = getDiscussionCaptureSettings();
@@ -61,12 +56,12 @@ var DiscussionService = class {
 		const project = input.contextProjectId ? this.projects.get(input.contextProjectId) : null;
 		if (input.contextProjectId && !project) throw new DiscussionServiceError("invalid_input", "Project not found");
 		const now = Date.now();
-		const title = placeholderTitle(now);
+		const title = placeholderTitle(input.recordedAt ?? now);
 		const note = await this.notes.createNote({
 			title,
 			markdown: "",
 			kind: "voice",
-			capturedVia: { channel: input.source }
+			capturedVia: { channel: input.source === "mobile" ? "app" : input.source }
 		});
 		const capture = {
 			id: randomUUID(),
@@ -80,7 +75,7 @@ var DiscussionService = class {
 			source: input.source,
 			status: "recording",
 			transcriptRevision: 0,
-			recordingStartedAt: now,
+			recordingStartedAt: input.recordedAt ?? now,
 			createdAt: now,
 			updatedAt: now
 		};
@@ -131,16 +126,17 @@ var DiscussionService = class {
 	metrics() {
 		return getDiscussionMetrics();
 	}
-	transcript(id) {
+	transcript(id, revision) {
 		const capture = getDiscussionCapture(id);
 		if (!capture) return null;
-		const segments = listDiscussionTranscriptSegments(id);
+		const segments = revision === void 0 ? listDiscussionTranscriptSegments(id) : readTranscriptRevision(id, revision);
+		if (!segments) return null;
 		const count = (status) => segments.filter((segment) => segment.status === status).length;
 		return {
 			discussionId: id,
-			revision: capture.transcriptRevision,
+			revision: revision ?? capture.transcriptRevision,
 			segments,
-			text: capture.canonicalTranscript ?? assembleDiscussionTranscript(segments),
+			text: revision === void 0 ? capture.canonicalTranscript ?? assembleDiscussionTranscript(segments) : assembleDiscussionTranscript(segments),
 			stats: {
 				...capture.expectedLastSequence != null ? { expected: capture.expectedLastSequence + 1 } : {},
 				uploaded: count("uploaded"),
@@ -159,7 +155,7 @@ var DiscussionService = class {
 		if (!Number.isInteger(input.sequence) || input.sequence < 0 || input.sequence > 2e3) throw new DiscussionServiceError("invalid_input", "Invalid segment sequence");
 		if (input.file.mimeType !== "audio/wav" && input.file.mimeType !== "audio/x-wav") throw new DiscussionServiceError("invalid_input", "Live transcript segments must be WAV audio");
 		if (input.file.buffer.length === 0 || input.file.buffer.length > 2097152) throw new DiscussionServiceError("invalid_input", "Live transcript segment is empty or too large");
-		if (!Number.isFinite(input.startedAtMs) || !Number.isFinite(input.endedAtMs) || input.startedAtMs < 0 || input.endedAtMs <= input.startedAtMs || input.endedAtMs - input.startedAtMs > 25e3) throw new DiscussionServiceError("invalid_input", "Invalid live transcript segment timing");
+		if (!Number.isFinite(input.startedAtMs) || !Number.isFinite(input.endedAtMs) || input.startedAtMs < 0 || input.endedAtMs <= input.startedAtMs || input.endedAtMs > 72e5 || input.endedAtMs - input.startedAtMs > 25e3) throw new DiscussionServiceError("invalid_input", "Invalid live transcript segment timing");
 		const actualSha256 = createHash("sha256").update(input.file.buffer).digest("hex");
 		if (input.sha256 !== actualSha256) throw new DiscussionServiceError("invalid_input", "Segment checksum mismatch");
 		if (originalRecordingSupersedesSegment) return this.transcript(input.discussionId);
@@ -186,89 +182,167 @@ var DiscussionService = class {
 		}
 		return this.transcript(input.discussionId);
 	}
-	correctSegment(id, sequence, displayText, expectedRevision) {
+	correctSegment(id, sequence, displayText, expectedRevision, speakerLabel, applyToSpeakerGroup = false, expectedTranscriptRevision) {
 		const capture = getDiscussionCapture(id);
 		if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
-		if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "The sealed transcript cannot be changed");
+		if (![
+			"recording",
+			"stopping",
+			"completed",
+			"needs_attention"
+		].includes(capture.status)) throw new DiscussionServiceError("conflict", "Wait until processing has finished before editing");
 		const text = displayText.trim();
 		if (!text || text.length > 2e4) throw new DiscussionServiceError("invalid_input", "Invalid transcript text");
-		const segment = correctDiscussionTranscriptSegment(id, sequence, text, expectedRevision);
-		if (!segment) throw new DiscussionServiceError("conflict", "Transcript segment changed; reload and try again");
-		const transcript = this.transcript(id);
+		if (speakerLabel && speakerLabel.length > 100) throw new DiscussionServiceError("invalid_input", "Speaker label is too long");
+		if (applyToSpeakerGroup && expectedTranscriptRevision !== capture.transcriptRevision) throw new DiscussionServiceError("conflict", "Transcript changed; reload before renaming the speaker");
+		const transcript = runSqliteWriteTransaction((db) => {
+			const originalSpeaker = getDiscussionTranscriptSegment(id, sequence)?.speakerLabel;
+			saveTranscriptRevision(id);
+			if (!correctDiscussionTranscriptSegment(id, sequence, text, expectedRevision, speakerLabel)) throw new DiscussionServiceError("conflict", "Transcript segment changed; reload and try again");
+			if (applyToSpeakerGroup && originalSpeaker && speakerLabel !== void 0) db.prepare("UPDATE discussion_transcript_segments SET speaker_label=?, corrected_by_user=1, corrected_at=?, revision=revision+1, updated_at=? WHERE discussion_id=? AND speaker_label=? AND sequence<>?").run(speakerLabel.trim() || null, Date.now(), Date.now(), id, originalSpeaker, sequence);
+			if (capture.canonicalTranscript) refreshCanonicalTranscript(id);
+			saveTranscriptRevision(id);
+			return this.transcript(id);
+		});
 		this.emit?.("discussion.segment.updated", {
 			discussionId: id,
 			noteId: capture.noteId,
-			transcriptRevision: transcript.revision,
-			segment,
-			text: transcript.text,
-			stats: transcript.stats
+			transcriptRevision: transcript.revision
 		});
 		return transcript;
 	}
-	async uploadRecording(id, file, durationMs) {
-		return this.enqueueMutation(id, async () => {
-			const capture = getDiscussionCapture(id);
-			if (!capture) return null;
-			if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "Discussion no longer accepts its recording");
-			if (!Number.isFinite(durationMs) || durationMs < 1e3 || durationMs > 18e5) throw new DiscussionServiceError("invalid_input", "durationMs must be between 1000 and 1800000");
-			if (!isSupportedAudioMimeType(file.mimeType)) throw new DiscussionServiceError("invalid_input", "Unsupported audio type");
-			if (file.buffer.length === 0 || file.buffer.length > 26214400) throw new DiscussionServiceError("invalid_input", "Audio must be between 1 byte and 25MB");
-			const audioSha256 = createHash("sha256").update(file.buffer).digest("hex");
-			if (capture.audioAttachmentId) {
-				if (capture.audioSha256 === audioSha256) return this.detail(capture);
-				throw new DiscussionServiceError("conflict", "Discussion already has different audio");
-			}
-			const attachment = await this.notes.addAttachment(capture.noteId, {
-				name: file.name.trim().slice(0, 200) || `discussion-${id}.webm`,
-				buffer: file.buffer,
-				mimeType: file.mimeType,
-				duration: Math.round(durationMs / 1e3),
-				retainWithoutReference: true
-			});
-			if (!attachment) throw new DiscussionServiceError("not_found", "Discussion note not found");
-			try {
-				const updated = updateDiscussionCapture(id, {
-					audioAttachmentId: attachment.id,
-					durationMs: Math.round(durationMs),
-					mimeType: file.mimeType,
-					audioSizeBytes: file.buffer.length,
-					audioSha256
-				}, ["recording", "stopping"]);
-				if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while storing audio");
-				this.emit?.("discussion.updated", updated);
-				return this.detail(updated);
-			} catch (error) {
-				await this.notes.removeAttachment(capture.noteId, attachment.id).catch(() => void 0);
-				throw error;
-			}
+	editSummary(id, input) {
+		const record = editMeeting(id, input);
+		this.emit?.("discussion.updated", {
+			id,
+			noteId: getDiscussionCapture(id)?.noteId,
+			organizationRevision: record.revision
 		});
+		return record;
 	}
-	async stop(id, lastSequence, durationMs) {
+	recordingChunks(id) {
+		if (!getDiscussionCapture(id)) throw new DiscussionServiceError("not_found", "Discussion not found");
+		return listRecordingChunks(id);
+	}
+	async reorganize(id, template = "general") {
+		if (![
+			"general",
+			"project",
+			"review",
+			"interview"
+		].includes(template)) throw new DiscussionServiceError("invalid_input", "Invalid meeting template");
 		return this.enqueueMutation(id, async () => {
 			const capture = getDiscussionCapture(id);
-			if (!capture) return null;
-			if (capture.status === "stopping" || capture.status === "sealing" || capture.status === "organizing" || capture.status === "completed") return this.detail(capture);
-			if (capture.status !== "recording") throw new DiscussionServiceError("conflict", "Discussion cannot be stopped");
-			if (!Number.isInteger(lastSequence) || lastSequence < -1 || lastSequence > 2e3) throw new DiscussionServiceError("invalid_input", "Invalid final segment sequence");
-			if (!Number.isFinite(durationMs) || durationMs < 1e3 || durationMs > 18e5) throw new DiscussionServiceError("invalid_input", "Invalid recording duration");
+			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");
 			const updated = updateDiscussionCapture(id, {
-				status: "stopping",
-				expectedLastSequence: lastSequence,
-				durationMs: Math.round(durationMs),
-				recordingStoppedAt: Date.now(),
-				failureStage: void 0,
+				status: "organizing",
+				template,
 				failureCode: void 0,
 				failureMessage: void 0
-			}, ["recording"]);
-			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while finishing");
+			}, [capture.status]);
 			this.emit?.("discussion.updated", updated);
 			return this.detail(updated);
 		});
 	}
+	async uploadRecordingChunk(id, sequence, sha256, body) {
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
+			if (![
+				"recording",
+				"stopping",
+				"needs_attention"
+			].includes(capture.status) || capture.audioDeletedAt || capture.audioAttachmentId) throw new DiscussionServiceError("conflict", "Recording no longer accepts chunks");
+			const job = getRecordingJob(id);
+			if (job && ["queued", "running"].includes(job.state)) throw new DiscussionServiceError("conflict", "Recording is being finalized");
+			return saveRecordingChunk(capture, sequence, sha256, body);
+		});
+	}
+	recordingJob(id) {
+		if (!getDiscussionCapture(id)) throw new DiscussionServiceError("not_found", "Discussion not found");
+		return getRecordingJob(id);
+	}
+	async sealRecording(id, input) {
+		if (!Number.isInteger(input.lastSequence) || input.lastSequence < -1 || input.lastSequence > 2e3) throw new DiscussionServiceError("invalid_input", "Invalid final segment sequence");
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
+			const job = getRecordingJob(id);
+			if (capture.audioAttachmentId && job?.state === "completed") return submitRecordingJob(id, input);
+			if (![
+				"recording",
+				"stopping",
+				"needs_attention"
+			].includes(capture.status) || capture.audioDeletedAt) throw new DiscussionServiceError("conflict", "Recording cannot be completed");
+			if (!capture.audioAttachmentId) validateRecordingManifest(capture, input);
+			const submitted = runSqliteWriteTransaction(() => {
+				const submitted = submitRecordingJob(id, input);
+				if (!updateDiscussionCapture(id, {
+					status: "stopping",
+					expectedLastSequence: input.lastSequence,
+					recordingStoppedAt: capture.recordingStoppedAt ?? Date.now(),
+					failureStage: void 0,
+					failureCode: void 0,
+					failureMessage: void 0
+				}, [capture.status])) throw new DiscussionServiceError("conflict", "Discussion changed while submitting recording");
+				return submitted;
+			});
+			this.emit?.("discussion.updated", getDiscussionCapture(id));
+			return submitted;
+		});
+	}
+	/** Runs inside the existing sealer lifecycle; unfinished leases survive process restart. */
+	async processRecordingJob() {
+		const job = claimRecordingJob(this.recordingOwner);
+		if (!job) return;
+		await this.enqueueMutation(job.discussionId, async () => {
+			const controller = new AbortController();
+			this.recordingControllers.set(job.discussionId, controller);
+			const assertLease = () => {
+				controller.signal.throwIfAborted();
+				if (!renewRecordingJob(job.id, this.recordingOwner)) throw new Error("Recording job lease expired");
+			};
+			const renewal = setInterval(() => {
+				if (!renewRecordingJob(job.id, this.recordingOwner)) controller.abort();
+			}, 15e3);
+			renewal.unref();
+			try {
+				assertLease();
+				const capture = getDiscussionCapture(job.discussionId);
+				if (!capture || capture.audioDeletedAt || capture.status === "cancelled") throw new Error("Recording is no longer available");
+				const updated = capture.audioAttachmentId ? capture : await completeRecording(capture, job.input, this.notes, assertLease, controller.signal);
+				if (finishRecordingJob(job.id, this.recordingOwner)) this.emit?.("discussion.updated", updated);
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				if (finishRecordingJob(job.id, this.recordingOwner, message)) {
+					const failed = updateDiscussionCapture(job.discussionId, {
+						status: "needs_attention",
+						failureStage: "audio_upload",
+						failureCode: "recording_finalize_failed",
+						failureMessage: message.slice(0, 1e3)
+					}, ["stopping"]);
+					if (failed) this.emit?.("discussion.updated", failed);
+				}
+				log.warn({
+					err: error,
+					discussionId: job.discussionId,
+					jobId: job.id
+				}, "Recording finalization failed");
+			} finally {
+				clearInterval(renewal);
+				this.recordingControllers.delete(job.discussionId);
+			}
+		});
+	}
 	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") {
+			await this.sealRecording(id, getRecordingJobInput(id));
+			return this.get(id);
+		}
 		const updated = updateDiscussionCapture(id, {
 			status: capture.canonicalTranscript ? "organizing" : "stopping",
 			...!capture.canonicalTranscript ? { recordingStoppedAt: Date.now() } : {},
@@ -281,15 +355,24 @@ var DiscussionService = class {
 		return this.detail(updated);
 	}
 	async cancel(id) {
-		const capture = getDiscussionCapture(id);
-		if (!capture) return null;
-		if (capture.status === "cancelled") return this.detail(capture);
-		if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "Only an active recording can be cancelled");
-		const updated = updateDiscussionCapture(id, { status: "cancelled" }, ["recording", "stopping"]);
-		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while cancelling");
-		deleteDiscussionSegmentAudio(id);
-		this.emit?.("discussion.updated", updated);
-		return this.detail(updated);
+		const active = getDiscussionCapture(id);
+		if (active && ["recording", "stopping"].includes(active.status)) {
+			cancelRecordingJob(id);
+			this.recordingControllers.get(id)?.abort();
+		}
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (capture.status === "cancelled") return this.detail(capture);
+			if (capture.status !== "recording" && capture.status !== "stopping") throw new DiscussionServiceError("conflict", "Only an active recording can be cancelled");
+			const updated = updateDiscussionCapture(id, { status: "cancelled" }, ["recording", "stopping"]);
+			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while cancelling");
+			cancelRecordingJob(id);
+			deleteDiscussionSegmentAudio(id);
+			await removeRecordingChunks(capture);
+			this.emit?.("discussion.updated", updated);
+			return this.detail(updated);
+		});
 	}
 	async deleteAudio(id) {
 		return this.enqueueMutation(id, async () => {
@@ -300,8 +383,9 @@ var DiscussionService = class {
 				"needs_attention",
 				"cancelled"
 			].includes(capture.status)) throw new DiscussionServiceError("conflict", "Audio cannot be deleted while discussion processing is active");
-			if (!capture.audioAttachmentId) return this.detail(capture);
-			await this.notes.removeAttachment(capture.noteId, capture.audioAttachmentId);
+			await removeRecordingChunks(capture);
+			cancelRecordingJob(id);
+			if (capture.audioAttachmentId) await this.notes.removeAttachment(capture.noteId, capture.audioAttachmentId);
 			deleteDiscussionSegmentAudio(id);
 			const updated = updateDiscussionCapture(id, {
 				audioAttachmentId: void 0,
@@ -329,10 +413,12 @@ var DiscussionService = class {
 	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,
 			note,
 			transcript: this.transcript(capture.id),
+			...recordingJob ? { recordingJob } : {},
 			...getLatestDiscussionOrganization(capture.id) ? { organization: getLatestDiscussionOrganization(capture.id) } : {}
 		};
 	}

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

@@ -1,145 +1,10 @@
-export declare const DISCUSSION_STATUSES: readonly ["recording", "stopping", "sealing", "organizing", "completed", "needs_attention", "cancelled"];
-export type DiscussionStatus = typeof DISCUSSION_STATUSES[number];
-export type DiscussionSource = 'web' | 'electron';
-export type DiscussionProjectInferenceSource = 'context' | 'exact_name' | 'model';
-export type DiscussionFailureStage = 'segment_upload' | 'segment_transcription' | 'audio_upload' | 'transcript_sealing' | 'organization';
-export interface DiscussionActionItem {
-    id: string;
-    title: string;
-    owner?: string;
-    dueDate?: string;
-    evidenceSegmentIds?: number[];
-}
-export interface DiscussionOrganization {
-    title: string;
-    summary: string;
-    keyPoints: string[];
-    decisions: string[];
-    actionItems: DiscussionActionItem[];
-    risks: string[];
-    openQuestions: string[];
-    projectCandidateId?: string;
-    projectConfidence?: number;
-    projectAlternativeConfidence?: number;
-}
-export interface DiscussionCapture {
-    id: string;
-    clientRequestId: string;
-    noteId: string;
-    projectId?: string;
-    audioAttachmentId?: string;
-    source: DiscussionSource;
-    status: DiscussionStatus;
-    durationMs?: number;
-    expectedLastSequence?: number;
-    mimeType?: string;
-    audioSizeBytes?: number;
-    audioSha256?: string;
-    canonicalTranscript?: string;
-    canonicalTranscriptSha256?: string;
-    transcriptLanguage?: string;
-    transcriptRevision: number;
-    generatedTitle?: string;
-    projectInferenceScore?: number;
-    projectInferenceSource?: DiscussionProjectInferenceSource;
-    failureStage?: DiscussionFailureStage;
-    failureCode?: string;
-    failureMessage?: string;
-    recordingStartedAt: number;
-    recordingStoppedAt?: number;
-    createdAt: number;
-    updatedAt: number;
-    completedAt?: number;
-    audioDeletedAt?: number;
-}
-export type DiscussionTranscriptSegmentStatus = 'uploaded' | 'transcribing' | 'confirmed' | 'failed';
-export interface DiscussionTranscriptSegment {
-    discussionId: string;
-    sequence: number;
-    audioSha256: string;
-    startedAtMs: number;
-    endedAtMs: number;
-    status: DiscussionTranscriptSegmentStatus;
-    rawText?: string;
-    displayText?: string;
-    language?: string;
-    provider?: string;
-    confidence?: number;
-    speakerLabel?: string;
-    revision: number;
-    correctedByUser: boolean;
-    correctedAt?: number;
-    attemptCount: number;
-    nextAttemptAt?: number;
-    leaseOwner?: string;
-    leaseExpiresAt?: number;
-    lastError?: string;
-    createdAt: number;
-    updatedAt: number;
-}
-export interface DiscussionTranscriptStats {
-    expected?: number;
-    uploaded: number;
-    transcribing: number;
-    confirmed: number;
-    failed: number;
-}
-export interface DiscussionTranscript {
-    discussionId: string;
-    revision: number;
-    segments: DiscussionTranscriptSegment[];
-    text: string;
-    stats: DiscussionTranscriptStats;
-}
-export interface DiscussionOrganizationRecord {
-    id: string;
-    discussionId: string;
-    revision: number;
-    inputTranscriptSha256: string;
-    promptVersion: string;
-    modelRef: string;
-    organization?: DiscussionOrganization;
-    status: 'running' | 'completed' | 'failed';
-    errorMessage?: string;
-    createdAt: number;
-    completedAt?: number;
-}
-export interface DiscussionCaptureSettings {
-    consentPolicyVersion: number;
-    consentAcknowledgedAt?: number;
-}
-export interface CreateDiscussionInput {
-    clientRequestId: string;
-    contextProjectId?: string;
-    consentPolicyVersion: number;
-    source: DiscussionSource;
-}
-export interface ListDiscussionsQuery {
-    status?: DiscussionStatus | 'active';
-    projectId?: string;
-    limit?: number;
-    offset?: number;
-}
-export interface DiscussionListResult {
-    items: DiscussionCapture[];
-    total: number;
-    limit: number;
-    offset: number;
-    hasMore: boolean;
-}
-export interface DiscussionMetrics {
-    total: number;
-    byStatus: Record<DiscussionStatus, number>;
-    averageTimeToFirstTranscriptMs: number | null;
-    averageTimeToCompleteMs: number | null;
-    totalSegments: number;
-    failedSegments: number;
-    retriedSegments: number;
-    averageSegmentLatencyMs: number | null;
-}
+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';
+import type { DiscussionCapture, DiscussionTranscript, DiscussionOrganizationRecord } from '@xopcai/gateway-contract';
 export interface DiscussionDetail {
     discussion: DiscussionCapture;
     note: import('../notes/types.js').Note;
     transcript: DiscussionTranscript;
     organization?: DiscussionOrganizationRecord;
+    recordingJob?: import('@xopcai/gateway-contract').DiscussionRecordingJob;
 }

package/dist/src/discussions/types.js

@@ -1,12 +1,2 @@
-//#region src/discussions/types.ts
-const DISCUSSION_STATUSES = [
-	"recording",
-	"stopping",
-	"sealing",
-	"organizing",
-	"completed",
-	"needs_attention",
-	"cancelled"
-];
-//#endregion
+import { DISCUSSION_STATUSES } from "../../packages/gateway-contract/src/discussions.js";
 export { DISCUSSION_STATUSES };

package/dist/src/extensions/lockfile.js

@@ -1,7 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_paths, resolveExtensionsDir, resolveExtensionsLockPath } from "../config/paths.js";
 import { init_write_file_atomic, writeTextAtomic } from "../infra/write-file-atomic.js";
+import { init_paths, resolveExtensionsDir, resolveExtensionsLockPath } from "../config/paths.js";
 import { dirname, join } from "path";
 import { existsSync } from "fs";
 import { mkdir, readFile } from "fs/promises";

package/dist/src/files/file-service.d.ts

@@ -42,4 +42,5 @@ export declare class FileSpaceService {
     }>;
     rootResource(spaceId: string): Promise<FileResource>;
     children(spaceId: string, path?: string): Promise<FileResource[]>;
+    recent(limit: number, maxFilesPerSpace?: number): Promise<FileResource[]>;
 }

package/dist/src/files/file-service.js

@@ -167,10 +167,83 @@ const MIME_TYPES = {
 	mov: "video/quicktime",
 	webm: "video/webm"
 };
+const RECENT_DIRECTORY_CONCURRENCY = 8;
+const RECENT_RESOURCE_CONCURRENCY = 16;
 function isWithin(root, target) {
 	const rel = relative(root, target);
 	return rel === "" || !rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel);
 }
+async function mapWithConcurrency(values, concurrency, mapper) {
+	const results = new Array(values.length);
+	let next = 0;
+	await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+		while (next < values.length) {
+			const index = next++;
+			results[index] = await mapper(values[index]);
+		}
+	}));
+	return results;
+}
+async function collectRecentCandidates(space, limit, maxFiles) {
+	const directories = [{
+		absolutePath: space.root,
+		displayPath: space.root
+	}];
+	const visited = /* @__PURE__ */ new Set();
+	const candidates = [];
+	let filesSeen = 0;
+	while (directories.length > 0 && filesSeen < maxFiles) {
+		const batch = directories.splice(0, RECENT_DIRECTORY_CONCURRENCY).filter((directory) => {
+			if (visited.has(directory.absolutePath)) return false;
+			visited.add(directory.absolutePath);
+			return true;
+		});
+		const scanned = await Promise.all(batch.map(async (directory) => {
+			const entries = [];
+			const handle = await opendir(directory.absolutePath).catch(() => null);
+			if (!handle) return entries;
+			for await (const entry of handle) if (!SKIPPED_NAMES.has(entry.name)) entries.push(entry);
+			return mapWithConcurrency(entries, RECENT_RESOURCE_CONCURRENCY, async (entry) => {
+				const absolutePath = resolve(directory.absolutePath, entry.name);
+				const displayPath = resolve(directory.displayPath, entry.name);
+				if (entry.isDirectory()) return { directory: {
+					absolutePath,
+					displayPath
+				} };
+				if (entry.isFile()) {
+					const info = await stat(absolutePath).catch(() => null);
+					return info?.isFile() ? { file: {
+						space,
+						absolutePath,
+						displayPath,
+						modifiedAt: Math.max(0, Math.round(info.mtimeMs))
+					} } : {};
+				}
+				if (!entry.isSymbolicLink()) return {};
+				const canonicalTarget = await realpath(absolutePath).catch(() => null);
+				if (!canonicalTarget || !isWithin(space.root, canonicalTarget)) return {};
+				const info = await stat(canonicalTarget).catch(() => null);
+				if (info?.isDirectory()) return { directory: {
+					absolutePath: canonicalTarget,
+					displayPath
+				} };
+				return info?.isFile() ? { file: {
+					space,
+					absolutePath: canonicalTarget,
+					displayPath,
+					modifiedAt: Math.max(0, Math.round(info.mtimeMs))
+				} } : {};
+			});
+		}));
+		for (const result of scanned.flat()) {
+			if (result.directory) directories.push(result.directory);
+			if (!result.file || filesSeen >= maxFiles) continue;
+			filesSeen += 1;
+			candidates.push(result.file);
+		}
+	}
+	return candidates.sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+}
 function normalizeRelativePath(input) {
 	const normalized = input.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "");
 	if (normalized.includes("\0") || normalized.split("/").some((part) => part === "..")) throw new FileServiceError(400, "Invalid file path");
@@ -439,6 +512,10 @@ var FileSpaceService = class {
 		}
 		return entries.sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === "directory" ? -1 : 1);
 	}
+	async recent(limit, maxFilesPerSpace = 5e3) {
+		const spaces = await this.list();
+		return (await mapWithConcurrency((await Promise.all(spaces.map((space) => collectRecentCandidates(space, limit, maxFilesPerSpace)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit), RECENT_RESOURCE_CONCURRENCY, async (candidate) => fileResourceFromPath(candidate.space, candidate.absolutePath, candidate.displayPath).catch(() => null))).filter((resource) => resource !== null);
+	}
 };
 //#endregion
 export { FileServiceError, FileSpaceService, fileResourceFromPath, fileResourceId, fileSpaceId, parseFileResourceId, resolveFilePath };