@agimon-ai/po-log 0.0.0-alpha.29 → 0.0.0-alpha.30

package/dist/extensions/server.cjs

@@ -29,9 +29,12 @@ let _agimon_ai_po_logsink = require("@agimon-ai/po-logsink");
 let _agimon_ai_po_core_serverPlugin = require("@agimon-ai/po-core/serverPlugin");
 let _agimon_ai_po_core_extensionFile = require("@agimon-ai/po-core/extensionFile");
 let _agimon_ai_po_core_childSession = require("@agimon-ai/po-core/childSession");
+let _agimon_ai_po_core_codemode = require("@agimon-ai/po-core/codemode");
 let _agimon_ai_po_core_workflow = require("@agimon-ai/po-core/workflow");
+let _agimon_ai_po_core_telemetry = require("@agimon-ai/po-core/telemetry");
+let _agimon_ai_po_logsink_queryContracts = require("@agimon-ai/po-logsink/queryContracts");
+let typebox = require("typebox");
 let _agimon_ai_po_core_runtimeJson = require("@agimon-ai/po-core/runtimeJson");
-let _agimon_ai_po_telemetry = require("@agimon-ai/po-telemetry");
 let hono = require("hono");
 let node_child_process = require("node:child_process");
 let node_module = require("node:module");
@@ -40,10 +43,254 @@ node_path = __toESM(node_path, 1);
 let _agimon_ai_po_core_web = require("@agimon-ai/po-core/web");
 let _agimon_ai_po_core_help = require("@agimon-ai/po-core/help");
 let typebox_value = require("typebox/value");
-let typebox = require("typebox");
 //#region src/constants/telemetry.ts
 const PACKAGE_NAME$1 = "@agimon-ai/po-log";
 //#endregion
+//#region src/schemas/logsink.ts
+const LOGSINK_METHODS = [
+	"status",
+	"search",
+	"agentIssues",
+	"trace",
+	"stats",
+	"services",
+	"metrics"
+];
+const LOGSINK_TOOL_NAMES = LOGSINK_METHODS.map((method) => `logsink_${method.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)}`);
+/** The direct tools advertise the same schema the reader validates, plus Po's scope selector. */
+function logsinkParameters(method) {
+	const schema = _agimon_ai_po_logsink_queryContracts.LOG_QUERY_INPUT_SCHEMAS[method];
+	return typebox.Type.Unsafe({
+		...schema,
+		properties: {
+			...schema.properties,
+			...method === "status" ? {} : { scope: {
+				type: "string",
+				enum: ["session", "history"],
+				description: "Defaults to this session. History requires explicit startTime and endTime."
+			} }
+		}
+	});
+}
+function parseLogsinkInput(method, value, sessionId) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Log query input must be an object.");
+	const { scope: requestedScope, ...query } = value;
+	const storedSessionId = (0, _agimon_ai_po_core_telemetry.sanitizeTelemetryAttributes)({ "pi.session.id": sessionId })["pi.session.id"];
+	if (typeof storedSessionId !== "string") throw new Error("Log queries require a valid session identity.");
+	if (method === "status") {
+		if (requestedScope !== void 0) throw new Error("status does not accept a scope.");
+		return {
+			scope: {
+				kind: "session",
+				sessionId: storedSessionId
+			},
+			input: (0, _agimon_ai_po_logsink_queryContracts.parseLogQueryInput)(method, query)
+		};
+	}
+	const kind = requestedScope ?? "session";
+	if (kind !== "session" && kind !== "history") throw new Error("scope must be session or history.");
+	if (kind === "session") {
+		if (query.sessionId !== void 0 && query.sessionId !== sessionId && query.sessionId !== storedSessionId) throw new Error("Use explicit history scope to query another session.");
+		query.sessionId = storedSessionId;
+	} else if (typeof query.startTime !== "string" || typeof query.endTime !== "string") throw new Error("History queries require explicit ISO startTime and endTime.");
+	const input = (0, _agimon_ai_po_logsink_queryContracts.parseLogQueryInput)(method, query);
+	const filters = input;
+	return {
+		scope: {
+			kind,
+			...typeof filters.sessionId === "string" ? { sessionId: filters.sessionId } : {},
+			...typeof filters.startTime === "string" ? { startTime: filters.startTime } : {},
+			...typeof filters.endTime === "string" ? { endTime: filters.endTime } : {}
+		},
+		input
+	};
+}
+//#endregion
+//#region src/services/logQuerySource/index.ts
+/** The host supplies its home; inspection must not run the sink's directory-creating resolver. */
+function createLogQuerySource(homeDirectory) {
+	if (!homeDirectory) throw new Error("Log queries require the host home directory.");
+	return (0, _agimon_ai_po_logsink.createAsyncLogQueryReader)({ dbPath: (0, _agimon_ai_po_logsink.resolveGlobalLogQueryDbPath)(homeDirectory) });
+}
+//#endregion
+//#region src/services/logsink/index.ts
+const DESCRIPTIONS = {
+	status: "Check whether retained Log Sink data is available without starting a collector.",
+	search: "Search retained logs with structured filters and optional FTS text.",
+	agentIssues: "Aggregate captured agent failures, then inspect bounded issue samples and coverage.",
+	trace: "Read a bounded chronological trace within the selected session or history scope.",
+	stats: "Aggregate retained log statistics within the selected scope.",
+	services: "List services with retained records within the selected scope.",
+	metrics: "Inspect captured token usage, tool turn costs, and failure metrics."
+};
+function createLogsinkOperations(options) {
+	return {
+		sessionId: options.sessionId,
+		async read(method, value = {}, inputSignal) {
+			const active = options.authorize(inputSignal);
+			const signal = AbortSignal.any([active, AbortSignal.timeout(25e3)]);
+			const parsed = parseLogsinkInput(method, value, options.sessionId);
+			signal.throwIfAborted();
+			const reader = options.createReader?.() ?? createLogQuerySource(options.homeDirectory);
+			let report;
+			try {
+				const data = method === "status" ? await reader.status(signal) : await reader[method](parsed.input, signal);
+				report = JSON.parse(JSON.stringify({
+					scope: parsed.scope,
+					data
+				}));
+			} finally {
+				await reader.close();
+			}
+			signal.throwIfAborted();
+			options.authorize(inputSignal);
+			return report;
+		}
+	};
+}
+function createLogsinkTool(method, operations) {
+	if (!operations) throw new Error("Log Sink tools require a session host.");
+	return (0, _agimon_ai_po_core_serverPlugin.defineTool)({
+		name: LOGSINK_TOOL_NAMES[LOGSINK_METHODS.indexOf(method)],
+		description: `${DESCRIPTIONS[method]} Defaults to this session. Cross-session workflow analysis requires scope: history and explicit startTime/endTime.`,
+		parameters: logsinkParameters(method),
+		async execute(input, execution) {
+			const report = await operations.read(method, input, execution.signal);
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(report)
+				}],
+				details: report
+			};
+		}
+	});
+}
+//#endregion
+//#region src/services/logsinkNamespace/index.ts
+const DECLARATIONS = `interface LogScope { kind: 'session' | 'history'; sessionId?: string; startTime?: string; endTime?: string }
+interface LogResponse<T> { scope: LogScope; data: T }
+interface LogFilters {
+  scope?: 'session' | 'history'; sessionId?: string; startTime?: string; endTime?: string;
+  workflowRunId?: string; workflowName?: string; jobName?: string; jobId?: string;
+  agentName?: string; workflowRunKey?: string; workflowWorkspace?: string; stepName?: string; phase?: string;
+  service?: string | string[];
+}
+interface LogAvailability { available: boolean; reason?: 'missing-database' }
+interface LogRecord {
+  id: string; timestamp: string; level: string; service: string; message: string;
+  sessionId: string | null; traceId: string | null; spanId: string | null;
+  metadata: Record<string, unknown> | null; errorType: string | null; errorMessage: string | null;
+  [field: string]: unknown;
+}
+interface LogSearch { mode: 'filter' | 'fts'; count: number; total: number; truncated: boolean; results: LogRecord[] }
+interface LogIssue {
+  category: string; timestamp: string; service: string; sessionId: string | null; tool: string | null;
+  errorType: string | null; message: string; detail: string | null; fingerprint: string; occurrenceCount: number;
+  traceId: string | null; spanId: string | null; [field: string]: unknown;
+}
+interface LogIssues {
+  scanned: number; matchingLogs: number; truncated: boolean; coveragePercent: number; oldestScannedTimestamp: string | null;
+  totalIssues: number; uniqueIncidents: number; byCategory: Record<string, number>; byTool: Record<string, number>;
+  byErrorType: Record<string, number>; bySession: Record<string, number>; issues: LogIssue[];
+}
+interface LogTraceEntry { timestamp: string; service: string; spanId: string | null; parentSpanId: string | null; level: string; message: string; [field: string]: unknown }
+interface LogTrace { traceId: string; count: number; truncated: boolean; timeline: LogTraceEntry[] }
+interface LogStats { groupBy: string; signalType: 'log' | 'span' | 'all'; totalEntries: number; statistics: { service: string; level: string; count: number }[] }
+interface LogServices { count: number; truncated: boolean; services: string[] }
+interface LogTokens { inputTokens: number; outputTokens: number; totalTokens: number; cachedInputTokens: number; reasoningOutputTokens: number; usageEventCount: number }
+interface LogTokenDistribution { samples: number; avgInputTokens: number; p50InputTokens: number; p90InputTokens: number; avgOutputTokens: number; p50OutputTokens: number; p90OutputTokens: number; avgTotalTokens: number; p50TotalTokens: number; p90TotalTokens: number }
+interface LogMetrics {
+  generatedAt: string; groupBy: string; sort: string; toolSort: string; period: string; bucket: string;
+  filters: Record<string, unknown>;
+  totals: LogTokens & { totalRecords: number; issueCount: number; groupCount: number; returnedGroups: number; tokenCoveragePercent: number; [field: string]: unknown };
+  groups: (LogTokens & { key: string; sessionId: string | null; issueCount: number; byCategory: Record<string, number>; [field: string]: unknown })[];
+  tools: { returnedTools: number; rows: { toolName: string; invocationCount: number; toolCallTurn: LogTokenDistribution; toolOutputImpact: LogTokenDistribution; [field: string]: unknown }[] };
+  timeline: (LogTokens & { bucketStart: string; label: string; totalRecords: number; issueCount: number })[];
+}
+declare const logsink: {
+  /** Retained storage availability, not proof that the collector is capturing now. */
+  status(): Promise<LogResponse<LogAvailability>>;
+  /** Scoped structured query or FTS search. History requires explicit startTime/endTime. order is filter-only and rejected with query. */
+  search(input?: LogFilters & { query?: string; mode?: 'fts'; level?: string | string[]; traceId?: string; spanId?: string; errorType?: string; parentSessionId?: string; workflowId?: string; signalType?: 'log' | 'span'; limit?: number; order?: 'asc' | 'desc' }): Promise<LogResponse<LogSearch>>;
+  /** Failure aggregates and deduplicated samples, including coverage and truncation. */
+  agentIssues(input?: LogFilters & { limit?: number; scanLimit?: number }): Promise<LogResponse<LogIssues>>;
+  /** A bounded trace, filtered within scope before retrieval. */
+  trace(input: LogFilters & { traceId: string; limit?: number }): Promise<LogResponse<LogTrace>>;
+  /** Counts by level, service, agent, workflow, job or signal. */
+  stats(input?: LogFilters & { groupBy?: 'level' | 'service' | 'both' | 'agent' | 'workflow' | 'job' | 'signal'; signalType?: 'log' | 'span' | 'all' }): Promise<LogResponse<LogStats>>;
+  /** Services that have retained records within scope. */
+  services(input?: LogFilters & { limit?: number }): Promise<LogResponse<LogServices>>;
+  /** Captured usage and tool turn costs, not exclusive per-tool token shares. */
+  metrics(input?: LogFilters & { model?: string | string[]; provider?: string | string[]; groupBy?: 'session' | 'workflow-run' | 'workflow-name' | 'job' | 'step' | 'agent' | 'model' | 'provider'; sort?: 'last-seen' | 'total-tokens' | 'issues'; toolSort?: 'p90-total-tokens' | 'avg-total-tokens' | 'invocations'; limit?: number; toolLimit?: number; period?: 'day' | 'week' | 'month' | 'all'; bucket?: 'hour' | 'day' | 'week' | 'month' }): Promise<LogResponse<LogMetrics>>;
+};`;
+function createLogsinkNamespace(operations) {
+	return {
+		name: "logsink",
+		summary: "Read captured log issues, metrics, traces and search results. Defaults to this session; explicit bounded history supports workflow analysis. Read-only, never manages the collector.",
+		declarations: DECLARATIONS,
+		bind(run) {
+			if (run.sessionId !== operations.sessionId) throw new Error("Log Sink namespace belongs to another session.");
+			let disposed = false;
+			const controller = new AbortController();
+			run.onDispose(() => {
+				disposed = true;
+				controller.abort(/* @__PURE__ */ new Error("Log Sink run is disposed."));
+			});
+			const signal = AbortSignal.any([run.signal, controller.signal]);
+			const check = () => {
+				signal.throwIfAborted();
+				if (disposed) throw new Error("Log Sink run is disposed.");
+			};
+			const members = Object.create(null);
+			for (const method of LOGSINK_METHODS) members[method] = async (input = {}) => {
+				const started = Date.now();
+				let args = {};
+				let result;
+				try {
+					check();
+					const snapshot = JSON.parse(JSON.stringify(input));
+					if (snapshot && typeof snapshot === "object" && !Array.isArray(snapshot)) args = snapshot;
+					result = await operations.read(method, input, signal);
+					check();
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					run.record?.({
+						name: `logsink.${method}`,
+						tool: LOGSINK_TOOL_NAMES[LOGSINK_METHODS.indexOf(method)],
+						args,
+						ok: false,
+						ms: Date.now() - started,
+						error: message,
+						result: { content: [{
+							type: "text",
+							text: message
+						}] }
+					});
+					throw error;
+				}
+				const details = JSON.parse(JSON.stringify(result));
+				run.record?.({
+					name: `logsink.${method}`,
+					tool: LOGSINK_TOOL_NAMES[LOGSINK_METHODS.indexOf(method)],
+					args,
+					ok: true,
+					ms: Date.now() - started,
+					result: {
+						content: [{
+							type: "text",
+							text: JSON.stringify(details)
+						}],
+						details
+					}
+				});
+				return result;
+			};
+			return members;
+		}
+	};
+}
+//#endregion
 //#region src/services/telemetryEnabled/index.ts
 function isEnabled(value) {
 	return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
@@ -179,12 +426,13 @@ function createServerTelemetry(options = {}) {
 	const activity = {
 		name: PACKAGE_NAME$1,
 		start(execution) {
-			const current = (0, _agimon_ai_po_telemetry.createPoTelemetry)({
+			const current = (0, _agimon_ai_po_core_telemetry.createPoTelemetry)({
 				serviceName: options.serviceName ?? "pi",
 				packageName: PACKAGE_NAME$1,
 				cwd: execution.cwd,
 				env: {
 					...options.env ?? execution.environment,
+					AGENT_SESSION_ID: execution.sessionId,
 					PI_SESSION_ID: execution.sessionId
 				},
 				allowFileFallback: options.allowFileFallback,
@@ -437,14 +685,41 @@ function createServerTelemetry(options = {}) {
 }
 //#endregion
 //#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
-const createLogServerRoot = ({ context }) => {
+const createLogServerRoot = ({ context, agent, host, signal: ownerSignal }) => {
 	const runtime = createServerTelemetry({
 		workflowContext: (0, _agimon_ai_po_core_workflow.readPoWorkflowContextService)(context),
 		childSessionHookRegistry: (0, _agimon_ai_po_core_childSession.readPoChildSessionHookRegistry)(context)
 	});
+	const sessionId = agent?.context.sessionId;
+	const logQueries = agent && sessionId ? createLogsinkOperations({
+		sessionId,
+		homeDirectory: host.context.homeDirectory,
+		authorize(signal) {
+			ownerSignal.throwIfAborted();
+			signal?.throwIfAborted();
+			agent.assertActive(PACKAGE_NAME$1);
+			if (agent.context.sessionId !== sessionId) throw new Error("Log Sink session changed.");
+			return signal ? AbortSignal.any([ownerSignal, signal]) : ownerSignal;
+		}
+	}) : void 0;
 	return {
-		value: runtime,
-		activities: runtime.activities
+		value: {
+			...runtime,
+			logQueries
+		},
+		activities: runtime.activities,
+		services: logQueries ? [(cordis) => {
+			cordis.inject([_agimon_ai_po_core_codemode.PO_CODEMODE_SERVICE], (scoped) => {
+				const codemode = (0, _agimon_ai_po_core_codemode.readPoCodemode)(scoped);
+				if (!codemode) return void 0;
+				const registration = codemode.register(PACKAGE_NAME$1, createLogsinkNamespace(logQueries));
+				const restriction = agent?.registerToolRestriction({ excludedTools: LOGSINK_TOOL_NAMES });
+				return () => {
+					restriction?.dispose();
+					registration.dispose();
+				};
+			});
+		}] : []
 	};
 };
 //#endregion
@@ -872,6 +1147,16 @@ var turn_end_server_default = (0, _agimon_ai_po_core_extensionFile.defineHook)((
 //#region src/extensions/workspaces/sessions/(backend)/hook/turn-start.server.ts
 var turn_start_server_default = (0, _agimon_ai_po_core_extensionFile.defineHook)((context) => context.root.hooks[3]);
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/codemode-how-to-logsink.server.ts
+var codemode_how_to_logsink_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)({
+	name: "codemode-how-to-logsink",
+	description: "Read captured failures, token usage, logs, and traces through code mode. Debug this session by default; explicitly select bounded cross-session history for workflow improvement.",
+	kind: "skill",
+	pinned: true,
+	path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-logsink/SKILL.md"),
+	read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/codemode-how-to-logsink/SKILL.md")
+});
+//#endregion
 //#region src/constants/diagnostics.ts
 const DIAGNOSE_AGENT_NAME = "diagnose_agent";
 const DIAGNOSE_AGENT_DESCRIPTION = "Inspect captured failures and token usage for the current Po session. Read-only, bounded to the last day or week; omits prompts, tool arguments, credentials, and unrelated sessions.";
@@ -889,14 +1174,14 @@ const AGENT_ISSUE_CATEGORIES = [
 	"log_error"
 ];
 //#endregion
-//#region src/extensions/workspaces/sessions/(backend)/resource/po-debug-agent.server.ts
-var po_debug_agent_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)({
-	name: "po-debug-agent",
+//#region src/extensions/workspaces/sessions/(backend)/resource/help-how-to-log.server.ts
+var help_how_to_log_server_default = (0, _agimon_ai_po_core_extensionFile.defineResource)({
+	name: "help-how-to-log",
 	description: "Debug a Po agent using session-scoped failure and usage evidence. Distinguish missing telemetry from a healthy run, diagnose expensive or failed tools, and investigate deeper traces without exposing secrets or changing the sink.",
 	when: _agimon_ai_po_core_help.PO_HELP_WHEN,
 	kind: "skill",
-	path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/po-debug-agent/SKILL.md"),
-	read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/po-debug-agent/SKILL.md")
+	path: (0, _agimon_ai_po_core_serverPlugin.packageResourcePath)(require("url").pathToFileURL(__filename).href, "src/prompts/help-how-to-log/SKILL.md"),
+	read: () => (0, _agimon_ai_po_core_serverPlugin.readPackageResource)(require("url").pathToFileURL(__filename).href, "src/prompts/help-how-to-log/SKILL.md")
 });
 //#endregion
 //#region src/schemas/agentDiagnostics.ts
@@ -1003,7 +1288,7 @@ async function readAgentDiagnostics(source, sessionId, input, signal) {
 			toolRowLimit: limit,
 			limitReached: report.tools.rows.length >= limit,
 			captureCompleteness: "not-reported",
-			limitations: "Only captured records in this window are represented. Empty data is not proof of a healthy run. Token coverage is not event-capture coverage; per-tool token samples describe the containing turn, not exclusive tool cost. Raw prompts, error messages, tool arguments and traces are omitted. Use po-debug-agent for deeper authorized investigation."
+			limitations: "Only captured records in this window are represented. Empty data is not proof of a healthy run. Token coverage is not event-capture coverage; per-tool token samples describe the containing turn, not exclusive tool cost. Raw prompts, error messages, tool arguments and traces are omitted. Use help-how-to-log for deeper authorized investigation."
 		};
 	} catch (error) {
 		if (signal.aborted) throw error;
@@ -1073,6 +1358,27 @@ var diagnose_agent_server_default = (0, _agimon_ai_po_core_extensionFile.defineT
 	});
 });
 //#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_agent_issues.server.ts
+var logsink_agent_issues_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("agentIssues", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_metrics.server.ts
+var logsink_metrics_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("metrics", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_search.server.ts
+var logsink_search_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("search", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_services.server.ts
+var logsink_services_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("services", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_stats.server.ts
+var logsink_stats_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("stats", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_status.server.ts
+var logsink_status_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("status", context.root.logQueries));
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/logsink_trace.server.ts
+var logsink_trace_server_default = (0, _agimon_ai_po_core_extensionFile.defineTool)((context) => createLogsinkTool("trace", context.root.logQueries));
+//#endregion
 //#region generated/server.ts
 const at = (value, context) => typeof value === "function" ? value(context) : value;
 const via = (identity, value) => value === void 0 ? void 0 : {
@@ -1118,10 +1424,19 @@ const serverPlugin = (0, _agimon_ai_po_core_serverPlugin.defineServerPlugin)({
 				];
 			},
 			get resources() {
-				return [at(po_debug_agent_server_default, contextSession)];
+				return [at(codemode_how_to_logsink_server_default, contextSession), at(help_how_to_log_server_default, contextSession)];
 			},
 			get tools() {
-				return [via({ name: "diagnose_agent" }, at(diagnose_agent_server_default, contextSession))];
+				return [
+					via({ name: "diagnose_agent" }, at(diagnose_agent_server_default, contextSession)),
+					via({ name: "logsink_agent_issues" }, at(logsink_agent_issues_server_default, contextSession)),
+					via({ name: "logsink_metrics" }, at(logsink_metrics_server_default, contextSession)),
+					via({ name: "logsink_search" }, at(logsink_search_server_default, contextSession)),
+					via({ name: "logsink_services" }, at(logsink_services_server_default, contextSession)),
+					via({ name: "logsink_stats" }, at(logsink_stats_server_default, contextSession)),
+					via({ name: "logsink_status" }, at(logsink_status_server_default, contextSession)),
+					via({ name: "logsink_trace" }, at(logsink_trace_server_default, contextSession))
+				];
 			},
 			services: [...scopeSession.services ?? []],
 			get activities() {