@xopcai/xopc 0.0.180 → 0.0.187

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

@@ -1,33 +0,0 @@
-import type { Config } from '../config/schema.js';
-import type { NotesService } from '../notes/service.js';
-import type { ProjectService } from '../projects/project-service.js';
-import type { DiscussionAnalysis, DiscussionCapture } from './types.js';
-export interface DiscussionTranscriptionResult {
-    text: string;
-    provider: string;
-    language?: string;
-}
-export interface DiscussionPipelineDeps {
-    notes: NotesService;
-    projects: ProjectService;
-    getConfig: () => Config;
-    transcribeAudio?: (buffer: Buffer, capture: DiscussionCapture, signal?: AbortSignal) => Promise<DiscussionTranscriptionResult>;
-    analyzeTranscript?: (transcript: string, capture: DiscussionCapture, signal?: AbortSignal) => Promise<{
-        analysis: DiscussionAnalysis;
-        modelRef: string;
-    }>;
-    onUpdated?: (capture: DiscussionCapture) => void;
-    onCompleted?: (capture: DiscussionCapture, analysis: DiscussionAnalysis) => void;
-}
-export declare function mergeDiscussionAnalysisIntoMarkdown(markdown: string, transcript: string, analysis: DiscussionAnalysis, audioRef?: string): string;
-export declare class DiscussionPipeline {
-    private readonly deps;
-    private readonly objectLinks;
-    constructor(deps: DiscussionPipelineDeps);
-    process(capture: DiscussionCapture, owner: string, signal?: AbortSignal): Promise<DiscussionCapture>;
-    private transcribe;
-    private analyze;
-    private writeNote;
-    private linkProject;
-    private defaultTranscribe;
-}

package/dist/src/discussions/pipeline.js

@@ -1,205 +0,0 @@
-import { buildNoteAttachmentRef } from "../notes/attachment-ref.js";
-import { ObjectLinkService } from "../activity/service.js";
-import { transcribe } from "../voice/stt/transcribe-core.js";
-import { isSTTAvailable } from "../voice/stt/availability.js";
-import { mergeSttConfigFromAppConfig } from "../voice/stt/config.js";
-import "../voice/stt/index.js";
-import { analyzeDiscussion } from "./analyzer.js";
-import { deleteDiscussionSegmentAudio, updateDiscussionCapture } from "./repository.js";
-import { acceptRankedProject, findExactProjectMention } from "./project-inference.js";
-import { createHash } from "node:crypto";
-import { readFile } from "node:fs/promises";
-//#region src/discussions/pipeline.ts
-const MANAGED_START = "<!-- xopc:discussion-analysis:start -->";
-const MANAGED_END = "<!-- xopc:discussion-analysis:end -->";
-function list(values) {
-	return values.length > 0 ? values.map((value) => `- ${value}`).join("\n") : "- None identified";
-}
-function renderManagedSection(transcript, analysis) {
-	const actions = analysis.actionItems.length > 0 ? analysis.actionItems.map((item) => {
-		const metadata = [item.owner ? `Owner: ${item.owner}` : "", item.dueDate ? `Due: ${item.dueDate}` : ""].filter(Boolean).join(" · ");
-		return `- [ ] ${item.title}${metadata ? ` — ${metadata}` : ""}`;
-	}).join("\n") : "- None identified";
-	return [
-		MANAGED_START,
-		"## Summary",
-		analysis.summary,
-		"",
-		"## Key points",
-		list(analysis.keyPoints),
-		"",
-		"## Decisions",
-		list(analysis.decisions),
-		"",
-		"## Action items",
-		actions,
-		"",
-		"## Risks",
-		list(analysis.risks),
-		"",
-		"## Open questions",
-		list(analysis.openQuestions),
-		"",
-		"## Transcript",
-		transcript.trim(),
-		MANAGED_END
-	].join("\n");
-}
-function mergeDiscussionAnalysisIntoMarkdown(markdown, transcript, analysis, audioRef) {
-	const managed = renderManagedSection(transcript, analysis);
-	const withoutPlaceholder = markdown.replace(/^> Recording in progress\. Live transcript will appear here\.\s*$/gm, "").replace(/^> Finalizing recording\.\.\.\s*$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
-	const start = withoutPlaceholder.indexOf(MANAGED_START);
-	const end = withoutPlaceholder.indexOf(MANAGED_END);
-	const base = start >= 0 && end >= start ? `${withoutPlaceholder.slice(0, start).trimEnd()}\n\n${managed}${withoutPlaceholder.slice(end + 37)}`.trim() : `${withoutPlaceholder}\n\n${managed}`.trim();
-	return audioRef && !base.includes(`](${audioRef})`) ? `${base}\n\n[Discussion audio](${audioRef})` : base;
-}
-var DiscussionPipeline = class {
-	objectLinks = new ObjectLinkService();
-	constructor(deps) {
-		this.deps = deps;
-	}
-	async process(capture, owner, signal) {
-		let current = capture;
-		if (!current.transcriptRaw) current = await this.transcribe(current, owner, signal);
-		if (!current.analysis) current = await this.analyze(current, owner, signal);
-		return this.writeNote(current);
-	}
-	async transcribe(capture, owner, signal) {
-		if (!capture.audioAttachmentId) throw new Error("Discussion audio attachment is missing");
-		const attachment = await this.deps.notes.getAttachmentPath(capture.noteId, capture.audioAttachmentId);
-		if (!attachment) throw new Error("Discussion audio file is missing");
-		const buffer = await readFile(attachment.filePath);
-		const result = this.deps.transcribeAudio ? await this.deps.transcribeAudio(buffer, capture, signal) : await this.defaultTranscribe(buffer, capture, attachment, signal);
-		const transcript = result.text.trim();
-		if (!transcript) throw new Error("Discussion transcription produced no text");
-		const updated = updateDiscussionCapture(capture.id, {
-			processingStage: "analysis",
-			transcriptRaw: transcript,
-			transcriptSha256: createHash("sha256").update(transcript).digest("hex"),
-			transcriptLanguage: result.language,
-			sttProvider: result.provider,
-			lastErrorCode: void 0,
-			lastErrorMessage: void 0,
-			leaseOwner: owner,
-			leaseExpiresAt: Date.now() + 5 * 6e4
-		}, ["finalizing"]);
-		if (!updated) throw new Error("Discussion changed while transcribing");
-		this.deps.onUpdated?.(updated);
-		return updated;
-	}
-	async analyze(capture, owner, signal) {
-		if (!capture.transcriptRaw) throw new Error("Discussion transcript is missing");
-		const projects = this.deps.projects.list({
-			status: "active",
-			limit: 100
-		}).items;
-		const result = this.deps.analyzeTranscript ? await this.deps.analyzeTranscript(capture.transcriptRaw, capture, signal) : await analyzeDiscussion({
-			config: this.deps.getConfig(),
-			transcript: capture.transcriptRaw,
-			projects: projects.map(({ id, name }) => ({
-				id,
-				name
-			})),
-			signal
-		});
-		const analysis = result.analysis;
-		let inferredProject;
-		if (!capture.projectId) {
-			const exact = findExactProjectMention(capture.transcriptRaw, projects);
-			const ranked = acceptRankedProject(analysis, projects);
-			if (exact) inferredProject = {
-				id: exact.id,
-				score: 1,
-				source: "exact_name"
-			};
-			else if (ranked) inferredProject = {
-				...ranked,
-				source: "model"
-			};
-		}
-		const updated = updateDiscussionCapture(capture.id, {
-			processingStage: "note_write",
-			analysis,
-			analysisInputHash: capture.transcriptSha256,
-			analyzerModelRef: result.modelRef,
-			generatedTitle: analysis.title,
-			...inferredProject ? {
-				projectId: inferredProject.id,
-				projectInferenceScore: inferredProject.score,
-				projectInferenceSource: inferredProject.source
-			} : {},
-			leaseOwner: owner,
-			leaseExpiresAt: Date.now() + 5 * 6e4
-		}, ["finalizing"]);
-		if (!updated) throw new Error("Discussion changed while analyzing");
-		if (inferredProject) this.linkProject(updated, inferredProject.id);
-		this.deps.onUpdated?.(updated);
-		return updated;
-	}
-	async writeNote(capture) {
-		if (!capture.transcriptRaw || !capture.analysis || !capture.audioAttachmentId) throw new Error("Discussion finalization data is incomplete");
-		const note = await this.deps.notes.getNote(capture.noteId);
-		if (!note) throw new Error("Discussion note is missing");
-		const title = capture.analysis.title.trim().slice(0, 200);
-		const audioRef = buildNoteAttachmentRef(capture.noteId, capture.audioAttachmentId);
-		const markdown = mergeDiscussionAnalysisIntoMarkdown(note.markdown, capture.transcriptRaw, capture.analysis, audioRef);
-		const attachments = (note.attachments ?? []).map((attachment) => attachment.id === capture.audioAttachmentId ? {
-			...attachment,
-			transcript: capture.transcriptRaw
-		} : attachment);
-		if (capture.projectId && capture.projectInferenceSource !== "context") this.linkProject(capture, capture.projectId);
-		if (note.title !== title || note.markdown !== markdown || note.status !== "processed") await this.deps.notes.updateNote(capture.noteId, {
-			title,
-			markdown,
-			attachments,
-			status: "processed"
-		}, "ai_edit");
-		const now = Date.now();
-		const updated = updateDiscussionCapture(capture.id, {
-			status: "completed",
-			processingStage: void 0,
-			finalizationRevision: capture.finalizationRevision + 1,
-			completedAt: now,
-			leaseOwner: void 0,
-			leaseExpiresAt: void 0,
-			nextAttemptAt: void 0,
-			lastErrorCode: void 0,
-			lastErrorMessage: void 0
-		}, ["finalizing"]);
-		if (!updated || updated.leaseOwner) throw new Error("Discussion changed while writing the note");
-		deleteDiscussionSegmentAudio(capture.id);
-		this.deps.onUpdated?.(updated);
-		this.deps.onCompleted?.(updated, capture.analysis);
-		return updated;
-	}
-	linkProject(capture, projectId) {
-		const project = this.deps.projects.get(projectId);
-		if (!project) return;
-		this.objectLinks.create({
-			id: `discussion:${capture.id}:project`,
-			from: {
-				kind: "note",
-				id: capture.noteId
-			},
-			to: {
-				kind: "project",
-				id: project.id,
-				title: project.name
-			},
-			relation: "belongs_to",
-			source: "agent"
-		});
-	}
-	async defaultTranscribe(buffer, capture, attachment, signal) {
-		const config = this.deps.getConfig();
-		const sttConfig = mergeSttConfigFromAppConfig(config.tools?.media?.audio, config.tools?.media);
-		if (!isSTTAvailable(sttConfig)) throw new Error("STT is not configured");
-		return transcribe(buffer, sttConfig, {
-			mime: attachment.mimeType || capture.mimeType,
-			fileName: attachment.fileName,
-			signal
-		});
-	}
-};
-//#endregion
-export { DiscussionPipeline, mergeDiscussionAnalysisIntoMarkdown };

package/dist/src/discussions/worker.js

@@ -1,74 +0,0 @@
-import { createLogger } from "../utils/logger/index.js";
-import { init_logger } from "../utils/logger.js";
-import { claimNextDiscussionCapture, getDiscussionCapture, updateDiscussionCapture } from "./repository.js";
-import { randomUUID } from "node:crypto";
-//#region src/discussions/worker.ts
-init_logger();
-const log = createLogger("DiscussionWorker");
-const MAX_ATTEMPTS = 3;
-var DiscussionWorker = class {
-	owner = randomUUID();
-	timer;
-	running = false;
-	stoppedWaiters = [];
-	constructor(processor, onUpdated, intervalMs = 2e3) {
-		this.processor = processor;
-		this.onUpdated = onUpdated;
-		this.intervalMs = intervalMs;
-	}
-	start() {
-		if (this.timer) return;
-		this.timer = setInterval(() => void this.tick(), this.intervalMs);
-		this.timer.unref();
-		this.tick();
-	}
-	async stop() {
-		if (this.timer) clearInterval(this.timer);
-		this.timer = void 0;
-		if (!this.running) return;
-		await new Promise((resolve) => this.stoppedWaiters.push(resolve));
-	}
-	async tick() {
-		if (this.running) return;
-		this.running = true;
-		try {
-			const capture = claimNextDiscussionCapture(this.owner);
-			if (!capture) return;
-			this.onUpdated?.(capture);
-			try {
-				await this.processor.process(capture, this.owner);
-			} catch (error) {
-				this.failOrRetry(capture.id, error);
-			}
-		} finally {
-			this.running = false;
-			const waiters = this.stoppedWaiters.splice(0);
-			for (const resolve of waiters) resolve();
-		}
-	}
-	failOrRetry(id, error) {
-		const current = getDiscussionCapture(id);
-		if (!current || current.leaseOwner !== this.owner) return;
-		const failedStage = current.processingStage ?? "final_transcription";
-		const exhausted = current.attemptCount >= MAX_ATTEMPTS;
-		const errorMessage = error instanceof Error ? error.message : String(error);
-		const updated = updateDiscussionCapture(id, {
-			status: exhausted ? "failed" : "finalizing",
-			leaseOwner: void 0,
-			leaseExpiresAt: void 0,
-			nextAttemptAt: exhausted ? void 0 : Date.now() + 2 ** current.attemptCount * 1e3,
-			lastErrorCode: `${failedStage}_failed`,
-			lastErrorMessage: errorMessage.slice(0, 1e3)
-		}, [current.status]);
-		if (updated) this.onUpdated?.(updated);
-		log.warn({
-			err: error,
-			discussionId: id,
-			failedStage,
-			attemptCount: current.attemptCount,
-			exhausted
-		}, `Discussion ${failedStage} failed: ${errorMessage}`);
-	}
-};
-//#endregion
-export { DiscussionWorker };

package/dist/src/gateway/hono/routes/dreaming.d.ts

@@ -1,3 +0,0 @@
-import type { Hono } from 'hono';
-import type { AuthenticatedRouteDeps } from './deps.js';
-export declare function registerDreamingRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/dreaming.js

@@ -1,323 +0,0 @@
-import { DREAMING_DIR_RELATIVE, DREAMING_LAST_RUN_RELATIVE, SHORT_TERM_PROMOTION_LOCK_RELATIVE, SHORT_TERM_RECALL_STORE_RELATIVE } from "../../../agent/memory/dreaming/constants.js";
-import { clearStaleDreamingLock, loadDreamingStore, resetDreamingStore } from "../../../agent/memory/dreaming/short-term-store.js";
-import { resolveDreamingAgentScope } from "../../../agent/memory/dreaming/scope.js";
-import { parseDreamingLastRunFile } from "../../../agent/memory/dreaming/last-run.js";
-import { runDreamingDeepPromotion } from "../../../agent/memory/dreaming/deep-promotion.js";
-import { readDreamingEvents } from "../../../agent/memory/dreaming/events.js";
-import { runLightSweep } from "../../../agent/memory/dreaming/light-sweep.js";
-import { runRemPatterns } from "../../../agent/memory/dreaming/rem-patterns.js";
-import { previewDreamingDeepPromotion } from "../../../agent/memory/dreaming/preview.js";
-import path from "node:path";
-import fs from "node:fs/promises";
-//#region src/gateway/hono/routes/dreaming.ts
-function isRecord(v) {
-	return v !== null && typeof v === "object" && !Array.isArray(v);
-}
-function resolveRouteScope(cfg) {
-	return resolveDreamingAgentScope(cfg);
-}
-async function readLockInfo(dreamingRoot) {
-	const lockPath = path.join(dreamingRoot, SHORT_TERM_PROMOTION_LOCK_RELATIVE);
-	try {
-		const [content, st] = await Promise.all([fs.readFile(lockPath, "utf-8"), fs.stat(lockPath)]);
-		return {
-			locked: true,
-			path: SHORT_TERM_PROMOTION_LOCK_RELATIVE,
-			content: content.trim(),
-			mtimeMs: st.mtimeMs
-		};
-	} catch (err) {
-		if (err?.code === "ENOENT") return { locked: false };
-		return {
-			locked: true,
-			path: SHORT_TERM_PROMOTION_LOCK_RELATIVE,
-			content: "unknown",
-			mtimeMs: void 0
-		};
-	}
-}
-async function readLastRun(dreamingRoot) {
-	const fullPath = path.join(dreamingRoot, DREAMING_LAST_RUN_RELATIVE);
-	try {
-		const text = await fs.readFile(fullPath, "utf-8");
-		let raw;
-		try {
-			raw = JSON.parse(text);
-		} catch (parseErr) {
-			return {
-				exists: true,
-				path: DREAMING_LAST_RUN_RELATIVE,
-				raw: null,
-				record: null,
-				parseError: parseErr instanceof Error ? parseErr.message : String(parseErr)
-			};
-		}
-		const record = parseDreamingLastRunFile(raw);
-		return {
-			exists: true,
-			path: DREAMING_LAST_RUN_RELATIVE,
-			raw,
-			record,
-			parseError: record ? null : "Invalid or unsupported last-run.json (expected v2 deep record)."
-		};
-	} catch (err) {
-		if (err?.code === "ENOENT") return { exists: false };
-		return {
-			exists: true,
-			path: DREAMING_LAST_RUN_RELATIVE,
-			raw: null,
-			record: null,
-			parseError: err instanceof Error ? err.message : String(err)
-		};
-	}
-}
-async function readPhaseLastRun(dreamingRoot, filename) {
-	const relPath = path.join(DREAMING_DIR_RELATIVE, filename);
-	const fullPath = path.join(dreamingRoot, relPath);
-	try {
-		const text = await fs.readFile(fullPath, "utf-8");
-		return {
-			exists: true,
-			path: relPath,
-			raw: JSON.parse(text)
-		};
-	} catch (err) {
-		if (err?.code === "ENOENT") return { exists: false };
-		return { exists: false };
-	}
-}
-function storeStats(store) {
-	const entries = Object.values(store.entries ?? {});
-	const promoted = entries.filter((e) => typeof e.promotedAt === "string" && e.promotedAt.trim());
-	const lastPromotedAt = promoted.map((e) => e.promotedAt).sort((a, b) => a < b ? 1 : a > b ? -1 : 0)[0];
-	return {
-		version: store.version,
-		updatedAt: store.updatedAt,
-		entryCount: entries.length,
-		promotedCount: promoted.length,
-		lastPromotedAt: lastPromotedAt ?? null
-	};
-}
-function registerDreamingRoutes(authenticated, deps) {
-	const { service } = deps;
-	authenticated.get("/api/dreaming", async (c) => {
-		const cfg = service.currentConfig;
-		let scope;
-		try {
-			scope = resolveRouteScope(cfg);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 404);
-		}
-		const { store } = await loadDreamingStore({ dreamingRoot: scope.memoriesDir });
-		const lock = await readLockInfo(scope.memoriesDir);
-		const [lastRun, lightLastRun, remLastRun] = await Promise.all([
-			readLastRun(scope.memoriesDir),
-			readPhaseLastRun(scope.memoriesDir, "last-run-light.json"),
-			readPhaseLastRun(scope.memoriesDir, "last-run-rem.json")
-		]);
-		return c.json({
-			ok: true,
-			payload: {
-				agentId: scope.agentId,
-				memory: scope.memory,
-				workspaceDir: scope.workspaceDir,
-				memoriesDir: scope.memoriesDir,
-				config: scope.config,
-				storePath: path.join(scope.memoriesDir, SHORT_TERM_RECALL_STORE_RELATIVE),
-				store: storeStats(store),
-				lock,
-				lastRun,
-				lightLastRun,
-				remLastRun
-			}
-		});
-	});
-	authenticated.get("/api/dreaming/preview", async (c) => {
-		const cfg = service.currentConfig;
-		let scope;
-		try {
-			scope = resolveRouteScope(cfg);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 404);
-		}
-		const rawLimit = c.req.query("limit");
-		const limit = rawLimit ? Number(rawLimit) : 20;
-		const preview = await previewDreamingDeepPromotion({
-			workspaceDir: scope.workspaceDir,
-			dreamingRoot: scope.memoriesDir,
-			config: scope.config.deep,
-			limit: Number.isFinite(limit) ? limit : 20
-		});
-		return c.json({
-			ok: true,
-			payload: preview
-		});
-	});
-	authenticated.post("/api/dreaming/run", async (c) => {
-		let body;
-		try {
-			body = await c.req.json();
-		} catch {
-			body = {};
-		}
-		const requestedPhase = isRecord(body) && typeof body.phase === "string" && [
-			"light",
-			"deep",
-			"rem"
-		].includes(body.phase) ? body.phase : "deep";
-		const cfg = service.currentConfig;
-		let scope;
-		try {
-			scope = resolveRouteScope(cfg);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 404);
-		}
-		const dreaming = scope.config;
-		if (!dreaming.enabled || !dreaming.phases[requestedPhase].enabled) return c.json({
-			ok: false,
-			error: { message: `Dreaming ${requestedPhase} phase is disabled in config. Enable it first.` }
-		}, 400);
-		try {
-			service.emit("dreaming.phase.start", {
-				agentId: scope.agentId,
-				phase: requestedPhase,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString()
-			});
-			const result = requestedPhase === "light" ? await runLightSweep({
-				workspaceDir: scope.workspaceDir,
-				dreamingRoot: scope.memoriesDir,
-				config: dreaming.phases.light
-			}) : requestedPhase === "rem" ? await runRemPatterns({
-				agentId: scope.agentId,
-				workspaceDir: scope.workspaceDir,
-				dreamingRoot: scope.memoriesDir,
-				config: dreaming.phases.rem,
-				sensitiveWritePolicy: cfg.userContext.privacy.sensitiveWritePolicy,
-				promotionWritePolicy: dreaming.promotionWritePolicy.decision
-			}) : await runDreamingDeepPromotion({
-				agentId: scope.agentId,
-				workspaceDir: scope.workspaceDir,
-				dreamingRoot: scope.memoriesDir,
-				config: dreaming.phases.deep,
-				sensitiveWritePolicy: cfg.userContext.privacy.sensitiveWritePolicy
-			});
-			service.emit("dreaming.phase.end", {
-				agentId: scope.agentId,
-				phase: requestedPhase,
-				ok: true,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString()
-			});
-			return c.json({
-				ok: true,
-				payload: {
-					agentId: scope.agentId,
-					phase: requestedPhase,
-					result
-				}
-			});
-		} catch (err) {
-			const em = err instanceof Error ? err.message : String(err);
-			service.emit("dreaming.phase.end", {
-				agentId: scope.agentId,
-				phase: requestedPhase,
-				ok: false,
-				error: em,
-				timestamp: (/* @__PURE__ */ new Date()).toISOString()
-			});
-			return c.json({
-				ok: false,
-				error: { message: em || "Failed to trigger job" }
-			}, 400);
-		}
-	});
-	authenticated.post("/api/dreaming/action", async (c) => {
-		const cfg = service.currentConfig;
-		let body;
-		try {
-			body = await c.req.json();
-		} catch {
-			body = {};
-		}
-		const action = isRecord(body) && typeof body.action === "string" ? body.action.trim() : "";
-		let scope;
-		try {
-			scope = resolveRouteScope(cfg);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 404);
-		}
-		if (action !== "reset_store" && action !== "clear_lock") return c.json({
-			ok: false,
-			error: { message: "Invalid action" }
-		}, 400);
-		if (action === "reset_store") {
-			await resetDreamingStore({ dreamingRoot: scope.memoriesDir });
-			return c.json({
-				ok: true,
-				payload: {
-					agentId: scope.agentId,
-					reset: true,
-					storePath: path.join(scope.memoriesDir, SHORT_TERM_RECALL_STORE_RELATIVE)
-				}
-			});
-		}
-		const lockPath = path.join(scope.memoriesDir, SHORT_TERM_PROMOTION_LOCK_RELATIVE);
-		try {
-			const cleared = await clearStaleDreamingLock(scope.memoriesDir);
-			return c.json({
-				ok: true,
-				payload: {
-					agentId: scope.agentId,
-					cleared,
-					lockPath
-				}
-			});
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 409);
-		}
-	});
-	authenticated.get("/api/dreaming/events", async (c) => {
-		const cfg = service.currentConfig;
-		let scope;
-		try {
-			scope = resolveRouteScope(cfg);
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			return c.json({
-				ok: false,
-				error: { message }
-			}, 404);
-		}
-		const rawLimit = c.req.query("limit");
-		const limit = rawLimit ? Math.min(Math.max(Number(rawLimit) || 50, 1), 200) : 50;
-		const events = await readDreamingEvents(scope.memoriesDir, limit);
-		return c.json({
-			ok: true,
-			payload: {
-				agentId: scope.agentId,
-				events
-			}
-		});
-	});
-}
-//#endregion
-export { registerDreamingRoutes };

package/dist/src/gateway/hono/routes/execution-receipts.d.ts

@@ -1,3 +0,0 @@
-import type { Hono } from 'hono';
-import type { AuthenticatedRouteDeps } from './deps.js';
-export declare function registerExecutionReceiptRoutes(authenticated: Hono, _deps: AuthenticatedRouteDeps): void;