@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/discussions/repository.js

@@ -0,0 +1,255 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/discussions/repository.ts
+function parseJson(value) {
+	if (!value) return void 0;
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+}
+function discussionFromRow(row) {
+	return {
+		id: row.id,
+		clientRequestId: row.client_request_id,
+		noteId: row.note_id,
+		...row.project_id ? { projectId: row.project_id } : {},
+		...row.audio_attachment_id ? { audioAttachmentId: row.audio_attachment_id } : {},
+		source: row.source,
+		status: row.status,
+		...row.processing_stage ? { processingStage: row.processing_stage } : {},
+		...row.duration_ms != null ? { durationMs: row.duration_ms } : {},
+		...row.expected_last_sequence != null ? { expectedLastSequence: row.expected_last_sequence } : {},
+		...row.mime_type ? { mimeType: row.mime_type } : {},
+		...row.audio_size_bytes != null ? { audioSizeBytes: row.audio_size_bytes } : {},
+		...row.audio_sha256 ? { audioSha256: row.audio_sha256 } : {},
+		...row.transcript_raw ? { transcriptRaw: row.transcript_raw } : {},
+		...row.transcript_sha256 ? { transcriptSha256: row.transcript_sha256 } : {},
+		...row.transcript_language ? { transcriptLanguage: row.transcript_language } : {},
+		...row.stt_provider ? { sttProvider: row.stt_provider } : {},
+		...row.analysis_json ? { analysis: parseJson(row.analysis_json) } : {},
+		...row.analysis_input_hash ? { analysisInputHash: row.analysis_input_hash } : {},
+		...row.analyzer_model_ref ? { analyzerModelRef: row.analyzer_model_ref } : {},
+		...row.generated_title ? { generatedTitle: row.generated_title } : {},
+		...row.project_inference_score != null ? { projectInferenceScore: row.project_inference_score } : {},
+		...row.project_inference_source ? { projectInferenceSource: row.project_inference_source } : {},
+		finalizationRevision: row.finalization_revision,
+		attemptCount: row.attempt_count,
+		...row.next_attempt_at != null ? { nextAttemptAt: row.next_attempt_at } : {},
+		...row.lease_owner ? { leaseOwner: row.lease_owner } : {},
+		...row.lease_expires_at != null ? { leaseExpiresAt: row.lease_expires_at } : {},
+		...row.last_error_code ? { lastErrorCode: row.last_error_code } : {},
+		...row.last_error_message ? { lastErrorMessage: row.last_error_message } : {},
+		recordingStartedAt: row.recording_started_at,
+		...row.recording_finished_at != null ? { recordingFinishedAt: row.recording_finished_at } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at,
+		...row.completed_at != null ? { completedAt: row.completed_at } : {},
+		...row.audio_deleted_at != null ? { audioDeletedAt: row.audio_deleted_at } : {}
+	};
+}
+function segmentFromRow(row) {
+	return {
+		discussionId: row.discussion_id,
+		sequence: row.sequence,
+		audioSha256: row.audio_sha256,
+		startedAtMs: row.started_at_ms,
+		endedAtMs: row.ended_at_ms,
+		status: row.status,
+		...row.transcript ? { transcript: row.transcript } : {},
+		...row.provider ? { provider: row.provider } : {},
+		attemptCount: row.attempt_count,
+		...row.next_attempt_at != null ? { nextAttemptAt: row.next_attempt_at } : {},
+		...row.lease_owner ? { leaseOwner: row.lease_owner } : {},
+		...row.lease_expires_at != null ? { leaseExpiresAt: row.lease_expires_at } : {},
+		...row.last_error ? { lastError: row.last_error } : {},
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function readOne(column, value) {
+	const row = getSqliteDatabase().prepare(`SELECT * FROM discussion_captures WHERE ${column} = ?`).get(value);
+	return row ? discussionFromRow(row) : null;
+}
+function createDiscussionCapture(capture) {
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO discussion_captures (
+      id, client_request_id, note_id, project_id, source, status,
+      processing_stage, project_inference_score, project_inference_source,
+      finalization_revision, attempt_count, recording_started_at, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(capture.id, capture.clientRequestId, capture.noteId, capture.projectId ?? null, capture.source, capture.status, capture.processingStage ?? null, capture.projectInferenceScore ?? null, capture.projectInferenceSource ?? null, capture.finalizationRevision, capture.attemptCount, capture.recordingStartedAt, capture.createdAt, capture.updatedAt));
+	return getDiscussionCapture(capture.id);
+}
+function getDiscussionCapture(id) {
+	return readOne("id", id);
+}
+function getDiscussionCaptureByClientRequestId(clientRequestId) {
+	return readOne("client_request_id", clientRequestId);
+}
+function getDiscussionCaptureByNoteId(noteId) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM discussion_captures WHERE note_id = ?").get(noteId);
+	return row ? discussionFromRow(row) : null;
+}
+function listDiscussionCaptures(query = {}) {
+	const clauses = [];
+	const params = [];
+	if (query.status === "active") clauses.push(`status NOT IN ('completed', 'cancelled')`);
+	else if (query.status) {
+		clauses.push("status = ?");
+		params.push(query.status);
+	}
+	if (query.projectId) {
+		clauses.push("project_id = ?");
+		params.push(query.projectId);
+	}
+	const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+	const limit = Math.min(100, Math.max(1, Math.floor(query.limit ?? 30)));
+	const offset = Math.max(0, Math.floor(query.offset ?? 0));
+	const db = getSqliteDatabase();
+	const total = db.prepare(`SELECT COUNT(*) AS total FROM discussion_captures ${where}`).get(...params).total;
+	const rows = db.prepare(`SELECT * FROM discussion_captures ${where}
+     ORDER BY updated_at DESC, id DESC LIMIT ? OFFSET ?`).all(...params, limit, offset);
+	return {
+		items: rows.map(discussionFromRow),
+		total,
+		limit,
+		offset,
+		hasMore: offset + rows.length < total
+	};
+}
+function getDiscussionMetrics() {
+	const db = getSqliteDatabase();
+	const rows = db.prepare("SELECT status, COUNT(*) AS count FROM discussion_captures GROUP BY status").all();
+	const timing = db.prepare(`SELECT
+      AVG((SELECT MIN(s.updated_at) FROM discussion_transcript_segments s
+        WHERE s.discussion_id = d.id AND s.status = 'completed') - d.recording_started_at) AS first_transcript_ms,
+      AVG(CASE WHEN d.completed_at IS NOT NULL THEN d.completed_at - d.recording_started_at END) AS complete_ms
+     FROM discussion_captures d`).get();
+	const byStatus = Object.fromEntries([
+		"recording",
+		"finalizing",
+		"completed",
+		"failed",
+		"cancelled"
+	].map((status) => [status, 0]));
+	for (const row of rows) byStatus[row.status] = row.count;
+	return {
+		total: rows.reduce((sum, row) => sum + row.count, 0),
+		byStatus,
+		averageTimeToFirstTranscriptMs: timing.first_transcript_ms == null ? null : Math.max(0, Math.round(timing.first_transcript_ms)),
+		averageTimeToCompleteMs: timing.complete_ms == null ? null : Math.round(timing.complete_ms)
+	};
+}
+function updateDiscussionCapture(id, patch, expectedStatuses) {
+	const existing = getDiscussionCapture(id);
+	if (!existing || expectedStatuses && !expectedStatuses.includes(existing.status)) return null;
+	const next = {
+		...existing,
+		...patch,
+		updatedAt: patch.updatedAt ?? Date.now()
+	};
+	const sql = `UPDATE discussion_captures SET
+    project_id = ?, audio_attachment_id = ?, source = ?, status = ?, processing_stage = ?,
+    duration_ms = ?, expected_last_sequence = ?, mime_type = ?, audio_size_bytes = ?, audio_sha256 = ?,
+    transcript_raw = ?, transcript_sha256 = ?, transcript_language = ?, stt_provider = ?, analysis_json = ?,
+    analysis_input_hash = ?, analyzer_model_ref = ?, generated_title = ?, project_inference_score = ?,
+    project_inference_source = ?, finalization_revision = ?, attempt_count = ?, next_attempt_at = ?,
+    lease_owner = ?, lease_expires_at = ?, last_error_code = ?, last_error_message = ?,
+    recording_started_at = ?, recording_finished_at = ?, updated_at = ?, completed_at = ?, audio_deleted_at = ?
+    WHERE id = ?${expectedStatuses?.length ? ` AND status IN (${expectedStatuses.map(() => "?").join(", ")})` : ""}`;
+	return runSqliteWriteTransaction((db) => db.prepare(sql).run(next.projectId ?? null, next.audioAttachmentId ?? null, next.source, next.status, next.processingStage ?? null, next.durationMs ?? null, next.expectedLastSequence ?? null, next.mimeType ?? null, next.audioSizeBytes ?? null, next.audioSha256 ?? null, next.transcriptRaw ?? null, next.transcriptSha256 ?? null, next.transcriptLanguage ?? null, next.sttProvider ?? null, next.analysis === void 0 ? null : JSON.stringify(next.analysis), next.analysisInputHash ?? null, next.analyzerModelRef ?? null, next.generatedTitle ?? null, next.projectInferenceScore ?? null, next.projectInferenceSource ?? null, next.finalizationRevision, next.attemptCount, next.nextAttemptAt ?? null, next.leaseOwner ?? null, next.leaseExpiresAt ?? null, next.lastErrorCode ?? null, next.lastErrorMessage ?? null, next.recordingStartedAt, next.recordingFinishedAt ?? null, next.updatedAt, next.completedAt ?? null, next.audioDeletedAt ?? null, id, ...expectedStatuses ?? []).changes) > 0 ? getDiscussionCapture(id) : null;
+}
+function claimNextDiscussionCapture(owner, now = Date.now(), leaseMs = 5 * 6e4) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT * FROM discussion_captures
+       WHERE status = 'finalizing'
+         AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
+         AND (lease_owner IS NULL OR lease_expires_at IS NULL OR lease_expires_at <= ?)
+       ORDER BY created_at ASC, id ASC LIMIT 1`).get(now, now);
+		if (!row) return null;
+		return db.prepare(`UPDATE discussion_captures SET attempt_count = attempt_count + 1,
+       next_attempt_at = NULL, lease_owner = ?, lease_expires_at = ?, updated_at = ?
+       WHERE id = ? AND status = 'finalizing'
+         AND (lease_owner IS NULL OR lease_expires_at IS NULL OR lease_expires_at <= ?)`).run(owner, now + leaseMs, now, row.id, now).changes > 0 ? getDiscussionCapture(row.id) : null;
+	});
+}
+function createDiscussionTranscriptSegment(input) {
+	const existing = getDiscussionTranscriptSegment(input.discussionId, input.sequence);
+	if (existing) return existing;
+	const now = input.now ?? Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`INSERT INTO discussion_transcript_segments (
+      discussion_id, sequence, audio_sha256, audio_blob, started_at_ms, ended_at_ms,
+      status, attempt_count, created_at, updated_at
+    ) VALUES (?, ?, ?, ?, ?, ?, 'uploaded', 0, ?, ?)`).run(input.discussionId, input.sequence, input.audioSha256, input.audioBuffer, input.startedAtMs, input.endedAtMs, now, now));
+	return getDiscussionTranscriptSegment(input.discussionId, input.sequence);
+}
+function getDiscussionTranscriptSegment(discussionId, sequence) {
+	const row = getSqliteDatabase().prepare("SELECT * FROM discussion_transcript_segments WHERE discussion_id = ? AND sequence = ?").get(discussionId, sequence);
+	return row ? segmentFromRow(row) : null;
+}
+function listDiscussionTranscriptSegments(discussionId) {
+	return getSqliteDatabase().prepare("SELECT * FROM discussion_transcript_segments WHERE discussion_id = ? ORDER BY sequence ASC").all(discussionId).map(segmentFromRow);
+}
+function claimNextDiscussionTranscriptSegment(owner, now = Date.now(), leaseMs = 2 * 6e4) {
+	return runSqliteWriteTransaction((db) => {
+		const row = db.prepare(`SELECT s.* FROM discussion_transcript_segments s
+       JOIN discussion_captures d ON d.id = s.discussion_id
+       WHERE (s.status = 'uploaded'
+         OR (s.status = 'transcribing' AND (s.lease_expires_at IS NULL OR s.lease_expires_at <= ?)))
+         AND d.status IN ('recording', 'finalizing')
+         AND (s.next_attempt_at IS NULL OR s.next_attempt_at <= ?)
+         AND NOT EXISTS (
+           SELECT 1 FROM discussion_transcript_segments earlier
+           WHERE earlier.discussion_id = s.discussion_id
+             AND earlier.sequence < s.sequence
+             AND earlier.status IN ('uploaded', 'transcribing')
+         )
+       ORDER BY s.created_at ASC, s.sequence ASC LIMIT 1`).get(now, now);
+		if (!row?.audio_blob) return null;
+		if (db.prepare(`UPDATE discussion_transcript_segments
+       SET status = 'transcribing', attempt_count = attempt_count + 1,
+         next_attempt_at = NULL, lease_owner = ?, lease_expires_at = ?, updated_at = ?
+       WHERE discussion_id = ? AND sequence = ?
+         AND (status = 'uploaded'
+           OR (status = 'transcribing' AND (lease_expires_at IS NULL OR lease_expires_at <= ?)))`).run(owner, now + leaseMs, now, row.discussion_id, row.sequence, now).changes === 0) return null;
+		const claimed = db.prepare("SELECT * FROM discussion_transcript_segments WHERE discussion_id = ? AND sequence = ?").get(row.discussion_id, row.sequence);
+		return {
+			...segmentFromRow(claimed),
+			audioBuffer: Buffer.from(claimed.audio_blob)
+		};
+	});
+}
+function completeDiscussionTranscriptSegment(discussionId, sequence, owner, transcript, provider) {
+	const now = Date.now();
+	return runSqliteWriteTransaction((db) => db.prepare(`UPDATE discussion_transcript_segments SET
+      status = 'completed', transcript = ?, provider = ?, audio_blob = NULL,
+      lease_owner = NULL, lease_expires_at = NULL, next_attempt_at = NULL,
+      last_error = NULL, updated_at = ?
+     WHERE discussion_id = ? AND sequence = ? AND status = 'transcribing' AND lease_owner = ?`).run(transcript, provider, now, discussionId, sequence, owner).changes) > 0 ? getDiscussionTranscriptSegment(discussionId, sequence) : null;
+}
+function retryOrFailDiscussionTranscriptSegment(discussionId, sequence, owner, error, exhausted) {
+	const now = Date.now();
+	return runSqliteWriteTransaction((db) => db.prepare(`UPDATE discussion_transcript_segments SET
+      status = ?, lease_owner = NULL, lease_expires_at = NULL,
+      next_attempt_at = ?, last_error = ?, audio_blob = CASE WHEN ? THEN NULL ELSE audio_blob END,
+      updated_at = ?
+     WHERE discussion_id = ? AND sequence = ? AND status = 'transcribing' AND lease_owner = ?`).run(exhausted ? "failed" : "uploaded", exhausted ? null : now + 2e3, error.slice(0, 1e3), exhausted ? 1 : 0, now, discussionId, sequence, owner).changes) > 0 ? getDiscussionTranscriptSegment(discussionId, sequence) : null;
+}
+function deleteDiscussionSegmentAudio(discussionId) {
+	runSqliteWriteTransaction((db) => db.prepare("UPDATE discussion_transcript_segments SET audio_blob = NULL WHERE discussion_id = ?").run(discussionId));
+}
+function getDiscussionCaptureSettings() {
+	const row = getSqliteDatabase().prepare(`SELECT consent_policy_version, consent_acknowledged_at
+     FROM discussion_capture_settings WHERE workspace_id = 'default'`).get();
+	return {
+		consentPolicyVersion: row.consent_policy_version,
+		...row.consent_acknowledged_at != null ? { consentAcknowledgedAt: row.consent_acknowledged_at } : {}
+	};
+}
+function acknowledgeDiscussionCaptureConsent(policyVersion) {
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => db.prepare(`UPDATE discussion_capture_settings SET consent_acknowledged_at = ?, updated_at = ?
+     WHERE workspace_id = 'default' AND consent_policy_version = ?`).run(now, now, policyVersion));
+	return getDiscussionCaptureSettings();
+}
+//#endregion
+export { acknowledgeDiscussionCaptureConsent, claimNextDiscussionCapture, claimNextDiscussionTranscriptSegment, completeDiscussionTranscriptSegment, createDiscussionCapture, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, listDiscussionCaptures, listDiscussionTranscriptSegments, retryOrFailDiscussionTranscriptSegment, updateDiscussionCapture };

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

@@ -0,0 +1,51 @@
+import type { NotesService } from '../notes/service.js';
+import type { ProjectService } from '../projects/project-service.js';
+import type { CreateDiscussionInput, DiscussionCaptureSettings, DiscussionDetail, DiscussionListResult, DiscussionMetrics, DiscussionTranscript, ListDiscussionsQuery } from './types.js';
+export declare const DISCUSSION_AUDIO_MAX_BYTES: number;
+export declare const DISCUSSION_SEGMENT_MAX_BYTES: number;
+export declare const DISCUSSION_MAX_DURATION_MS: number;
+export declare class DiscussionServiceError extends Error {
+    readonly code: 'invalid_input' | 'not_found' | 'conflict';
+    constructor(code: 'invalid_input' | 'not_found' | 'conflict', message: string);
+}
+export declare class DiscussionService {
+    private readonly notes;
+    private readonly projects;
+    private readonly emit?;
+    private readonly createsInFlight;
+    private readonly mutationTails;
+    private readonly objectLinks;
+    constructor(notes: NotesService, projects: ProjectService, emit?: (type: string, payload: unknown) => void);
+    settings(): DiscussionCaptureSettings;
+    acknowledgeConsent(policyVersion: number): DiscussionCaptureSettings;
+    create(input: CreateDiscussionInput): Promise<DiscussionDetail>;
+    private createOnce;
+    get(id: string): Promise<DiscussionDetail | null>;
+    getByNoteId(noteId: string): Promise<DiscussionDetail | null>;
+    list(query?: ListDiscussionsQuery): DiscussionListResult;
+    metrics(): DiscussionMetrics;
+    transcript(id: string): DiscussionTranscript | null;
+    uploadSegment(input: {
+        discussionId: string;
+        sequence: number;
+        file: {
+            buffer: Buffer;
+            mimeType: string;
+        };
+        startedAtMs: number;
+        endedAtMs: number;
+        sha256: string;
+    }): DiscussionTranscript;
+    uploadRecording(id: string, file: {
+        name: string;
+        buffer: Buffer;
+        mimeType: string;
+    }, durationMs: number): Promise<DiscussionDetail | null>;
+    finish(id: string, lastSequence: number, durationMs: number): Promise<DiscussionDetail | null>;
+    retry(id: string): Promise<DiscussionDetail | null>;
+    cancel(id: string): Promise<DiscussionDetail | null>;
+    deleteAudio(id: string): Promise<DiscussionDetail | null>;
+    unlinkInferredProject(id: string): Promise<DiscussionDetail | null>;
+    private detail;
+    private enqueueMutation;
+}

package/dist/src/discussions/service.js

@@ -0,0 +1,335 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { buildNoteAttachmentRef } from "../notes/attachment-ref.js";
+import { ObjectLinkService } from "../activity/service.js";
+import { acknowledgeDiscussionCaptureConsent, createDiscussionCapture, createDiscussionTranscriptSegment, deleteDiscussionSegmentAudio, getDiscussionCapture, getDiscussionCaptureByClientRequestId, getDiscussionCaptureByNoteId, getDiscussionCaptureSettings, getDiscussionMetrics, getDiscussionTranscriptSegment, listDiscussionCaptures, listDiscussionTranscriptSegments, updateDiscussionCapture } from "./repository.js";
+import { assembleDiscussionTranscript } from "./transcript.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", " ")}`;
+}
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+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();
+	constructor(notes, projects, emit) {
+		this.notes = notes;
+		this.projects = projects;
+		this.emit = emit;
+	}
+	settings() {
+		return getDiscussionCaptureSettings();
+	}
+	acknowledgeConsent(policyVersion) {
+		if (policyVersion !== getDiscussionCaptureSettings().consentPolicyVersion) throw new DiscussionServiceError("conflict", "Recording consent policy changed; review it again");
+		return acknowledgeDiscussionCaptureConsent(policyVersion);
+	}
+	async create(input) {
+		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();
+		if (input.consentPolicyVersion !== settings.consentPolicyVersion || settings.consentAcknowledgedAt == null) throw new DiscussionServiceError("conflict", "Recording consent must be acknowledged first");
+		const existing = getDiscussionCaptureByClientRequestId(clientRequestId);
+		if (existing) return this.detail(existing);
+		const pending = this.createsInFlight.get(clientRequestId);
+		if (pending) return pending;
+		const creation = this.createOnce({
+			...input,
+			clientRequestId
+		}).finally(() => this.createsInFlight.delete(clientRequestId));
+		this.createsInFlight.set(clientRequestId, creation);
+		return creation;
+	}
+	async createOnce(input) {
+		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 note = await this.notes.createNote({
+			title,
+			markdown: `# ${title}\n\n> Recording in progress. Live transcript will appear here.`,
+			kind: "voice",
+			capturedVia: { channel: input.source }
+		});
+		const capture = {
+			id: randomUUID(),
+			clientRequestId: input.clientRequestId,
+			noteId: note.id,
+			...project ? {
+				projectId: project.id,
+				projectInferenceScore: 1,
+				projectInferenceSource: "context"
+			} : {},
+			source: input.source,
+			status: "recording",
+			processingStage: "original_upload",
+			finalizationRevision: 0,
+			attemptCount: 0,
+			recordingStartedAt: now,
+			createdAt: now,
+			updatedAt: now
+		};
+		try {
+			runSqliteWriteTransaction(() => {
+				createDiscussionCapture(capture);
+				if (project) this.objectLinks.create({
+					id: `discussion:${capture.id}:project`,
+					from: {
+						kind: "note",
+						id: note.id,
+						title: note.title
+					},
+					to: {
+						kind: "project",
+						id: project.id,
+						title: project.name
+					},
+					relation: "belongs_to",
+					source: "user",
+					nowMs: now
+				});
+			});
+		} catch (error) {
+			await this.notes.deleteNote(note.id).catch(() => void 0);
+			throw error;
+		}
+		const discussion = getDiscussionCapture(capture.id);
+		log.info({
+			discussionId: discussion.id,
+			noteId: note.id,
+			projectId: project?.id
+		}, "Discussion recording started");
+		this.emit?.("discussion.updated", discussion);
+		return {
+			discussion,
+			note
+		};
+	}
+	async get(id) {
+		const capture = getDiscussionCapture(id);
+		return capture ? this.detail(capture) : null;
+	}
+	async getByNoteId(noteId) {
+		const capture = getDiscussionCaptureByNoteId(noteId);
+		return capture ? this.detail(capture) : null;
+	}
+	list(query = {}) {
+		return listDiscussionCaptures(query);
+	}
+	metrics() {
+		return getDiscussionMetrics();
+	}
+	transcript(id) {
+		if (!getDiscussionCapture(id)) return null;
+		const segments = listDiscussionTranscriptSegments(id);
+		return {
+			discussionId: id,
+			segments,
+			text: assembleDiscussionTranscript(segments)
+		};
+	}
+	uploadSegment(input) {
+		const capture = getDiscussionCapture(input.discussionId);
+		if (!capture) throw new DiscussionServiceError("not_found", "Discussion not found");
+		if (capture.status !== "recording") throw new DiscussionServiceError("conflict", "Discussion is no longer recording");
+		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");
+		const actualSha256 = createHash("sha256").update(input.file.buffer).digest("hex");
+		if (input.sha256 !== actualSha256) throw new DiscussionServiceError("invalid_input", "Segment checksum mismatch");
+		const existing = getDiscussionTranscriptSegment(input.discussionId, input.sequence);
+		if (existing && existing.audioSha256 !== actualSha256) throw new DiscussionServiceError("conflict", "Segment sequence already contains different audio");
+		if (!existing) {
+			createDiscussionTranscriptSegment({
+				discussionId: input.discussionId,
+				sequence: input.sequence,
+				audioSha256: actualSha256,
+				audioBuffer: input.file.buffer,
+				startedAtMs: Math.round(input.startedAtMs),
+				endedAtMs: Math.round(input.endedAtMs)
+			});
+			this.emit?.("discussion.transcript.updated", {
+				discussionId: input.discussionId,
+				sequence: input.sequence
+			});
+		}
+		return this.transcript(input.discussionId);
+	}
+	async uploadRecording(id, file, durationMs) {
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (capture.status !== "recording") throw new DiscussionServiceError("conflict", "Discussion is no longer 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 noteBefore = await this.notes.getNote(capture.noteId);
+			if (!noteBefore) throw new DiscussionServiceError("not_found", "Discussion note not found");
+			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)
+			});
+			if (!attachment) throw new DiscussionServiceError("not_found", "Discussion note not found");
+			const audioRef = buildNoteAttachmentRef(capture.noteId, attachment.id);
+			try {
+				if (!noteBefore.markdown.includes(`](${audioRef})`)) {
+					if (!await this.notes.updateNote(capture.noteId, { markdown: `${noteBefore.markdown.trim()}\n\n[Discussion audio](${audioRef})` })) throw new DiscussionServiceError("not_found", "Discussion note not found");
+				}
+				const updated = updateDiscussionCapture(id, {
+					audioAttachmentId: attachment.id,
+					durationMs: Math.round(durationMs),
+					mimeType: file.mimeType,
+					audioSizeBytes: file.buffer.length,
+					audioSha256
+				}, ["recording"]);
+				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.updateNote(capture.noteId, { markdown: noteBefore.markdown }).catch(() => void 0);
+				await this.notes.removeAttachment(capture.noteId, attachment.id).catch(() => void 0);
+				throw error;
+			}
+		});
+	}
+	async finish(id, lastSequence, durationMs) {
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (capture.status === "finalizing" || capture.status === "completed") return this.detail(capture);
+			if (capture.status !== "recording") throw new DiscussionServiceError("conflict", "Discussion cannot be finished");
+			if (!capture.audioAttachmentId) throw new DiscussionServiceError("conflict", "Original recording has not been uploaded");
+			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");
+			const updated = updateDiscussionCapture(id, {
+				status: "finalizing",
+				processingStage: "final_transcription",
+				expectedLastSequence: lastSequence,
+				durationMs: Math.round(durationMs),
+				recordingFinishedAt: Date.now(),
+				attemptCount: 0,
+				nextAttemptAt: void 0,
+				lastErrorCode: void 0,
+				lastErrorMessage: void 0
+			}, ["recording"]);
+			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while finishing");
+			this.emit?.("discussion.updated", updated);
+			return this.detail(updated);
+		});
+	}
+	async retry(id) {
+		const capture = getDiscussionCapture(id);
+		if (!capture) return null;
+		if (capture.status !== "failed") throw new DiscussionServiceError("conflict", "Only failed discussions can be retried");
+		const updated = updateDiscussionCapture(id, {
+			status: "finalizing",
+			processingStage: capture.processingStage ?? "final_transcription",
+			attemptCount: 0,
+			nextAttemptAt: void 0,
+			leaseOwner: void 0,
+			leaseExpiresAt: void 0,
+			lastErrorCode: void 0,
+			lastErrorMessage: void 0
+		}, ["failed"]);
+		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while retrying");
+		this.emit?.("discussion.updated", updated);
+		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") throw new DiscussionServiceError("conflict", "Only an active recording can be cancelled");
+		const updated = updateDiscussionCapture(id, {
+			status: "cancelled",
+			processingStage: void 0
+		}, ["recording"]);
+		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while cancelling");
+		deleteDiscussionSegmentAudio(id);
+		this.emit?.("discussion.updated", updated);
+		return this.detail(updated);
+	}
+	async deleteAudio(id) {
+		return this.enqueueMutation(id, async () => {
+			const capture = getDiscussionCapture(id);
+			if (!capture) return null;
+			if (capture.status === "recording" || capture.status === "finalizing") throw new DiscussionServiceError("conflict", "Audio cannot be deleted while recording or finalizing");
+			if (!capture.audioAttachmentId) return this.detail(capture);
+			const note = await this.notes.getNote(capture.noteId);
+			if (!note) throw new DiscussionServiceError("not_found", "Discussion note not found");
+			const audioRef = buildNoteAttachmentRef(capture.noteId, capture.audioAttachmentId);
+			const markdown = note.markdown.replace(new RegExp(`^\\[Discussion audio\\]\\(${escapeRegExp(audioRef)}\\)\\s*$`, "gm"), "").replace(/\n{3,}/g, "\n\n").trim();
+			if (markdown !== note.markdown) await this.notes.updateNote(capture.noteId, { markdown });
+			await this.notes.removeAttachment(capture.noteId, capture.audioAttachmentId);
+			deleteDiscussionSegmentAudio(id);
+			const updated = updateDiscussionCapture(id, {
+				audioAttachmentId: void 0,
+				audioDeletedAt: Date.now()
+			}, [capture.status]);
+			if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while deleting audio");
+			this.emit?.("discussion.updated", updated);
+			return this.detail(updated);
+		});
+	}
+	async unlinkInferredProject(id) {
+		const capture = getDiscussionCapture(id);
+		if (!capture) return null;
+		if (!capture.projectId || capture.projectInferenceSource === "context") throw new DiscussionServiceError("conflict", "The project association is not AI-inferred");
+		this.objectLinks.delete(`discussion:${id}:project`);
+		const updated = updateDiscussionCapture(id, {
+			projectId: void 0,
+			projectInferenceScore: void 0,
+			projectInferenceSource: void 0
+		}, [capture.status]);
+		if (!updated) throw new DiscussionServiceError("conflict", "Discussion changed while unlinking project");
+		this.emit?.("discussion.updated", updated);
+		return this.detail(updated);
+	}
+	async detail(capture) {
+		const note = await this.notes.getNote(capture.noteId);
+		if (!note) throw new DiscussionServiceError("not_found", "Discussion note not found");
+		return {
+			discussion: capture,
+			note
+		};
+	}
+	enqueueMutation(id, mutation) {
+		const previous = this.mutationTails.get(id);
+		const tracked = (previous ? previous.catch(() => void 0) : Promise.resolve()).then(mutation).finally(() => {
+			if (this.mutationTails.get(id) === tracked) this.mutationTails.delete(id);
+		});
+		this.mutationTails.set(id, tracked);
+		return tracked;
+	}
+};
+//#endregion
+export { DISCUSSION_AUDIO_MAX_BYTES, DISCUSSION_MAX_DURATION_MS, DISCUSSION_SEGMENT_MAX_BYTES, DiscussionService, DiscussionServiceError };

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

@@ -0,0 +1,3 @@
+import type { DiscussionTranscriptSegment } from './types.js';
+export declare function appendTranscriptWithoutOverlap(existing: string, next: string): string;
+export declare function assembleDiscussionTranscript(segments: DiscussionTranscriptSegment[]): string;

package/dist/src/discussions/transcript.js

@@ -0,0 +1,15 @@
+//#region src/discussions/transcript.ts
+function appendTranscriptWithoutOverlap(existing, next) {
+	const left = existing.trim();
+	const right = next.trim();
+	if (!left) return right;
+	if (!right) return left;
+	const max = Math.min(200, left.length, right.length);
+	for (let size = max; size >= 8; size -= 1) if (left.slice(-size).toLocaleLowerCase() === right.slice(0, size).toLocaleLowerCase()) return `${left}${right.slice(size)}`.trim();
+	return `${left}\n${right}`;
+}
+function assembleDiscussionTranscript(segments) {
+	return segments.reduce((text, segment) => appendTranscriptWithoutOverlap(text, segment.transcript ?? ""), "");
+}
+//#endregion
+export { appendTranscriptWithoutOverlap, assembleDiscussionTranscript };