@agimon-ai/po-log 0.0.0-alpha.0

package/dist/extensions/server.mjs

@@ -0,0 +1,1006 @@
+import { t as createMetricsSource } from "../metricsSource-DXZLawQu.mjs";
+import { createRequire } from "node:module";
+import { resolveLogSinkInstance } from "@agimon-ai/log-sink-mcp";
+import { composeServerProviderOverrides, defineServerPlugin, defineTool, packageResourcePath, readPackageResource } from "@agimon-ai/po-core/serverFacet";
+import { composeRootHooks, defineHook, defineResource, defineRoot, defineRoute, defineServerCommand, defineTool as defineTool$1 } from "@agimon-ai/po-core/extensionFile";
+import { isRecord } from "@agimon-ai/po-core/runtimeJson";
+import { createDoomTelemetry } from "@agimon-ai/po-telemetry";
+import { Hono } from "hono";
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { apiResponse, defineApiRoutes } from "@agimon-ai/po-core/web";
+import { DOOM_HELP_WHEN } from "@agimon-ai/po-core/help";
+import { Check } from "typebox/value";
+import { Type } from "typebox";
+//#region src/constants/telemetry.ts
+const PACKAGE_NAME$1 = "@agimon-ai/po-log";
+//#endregion
+//#region src/services/telemetryEnabled/index.ts
+function isEnabled(value) {
+	return value === "1" || value?.toLowerCase() === "true" || value?.toLowerCase() === "yes";
+}
+//#endregion
+//#region src/services/serverTelemetry/index.ts
+function contextAttributes(execution) {
+	return {
+		"pi.mode": "json",
+		"pi.session.id": execution.sessionId,
+		...execution.model === void 0 ? {} : {
+			"gen_ai.provider.name": execution.model.provider,
+			"gen_ai.request.model": execution.model.id
+		}
+	};
+}
+/** Headless hooks carry untrusted records, not Pi's typed assistant messages. */
+function usageAttributes(message) {
+	const usage = isRecord(message.usage) ? message.usage : {};
+	const attributes = {};
+	for (const [field, attribute] of Object.entries({
+		input: "gen_ai.usage.input_tokens",
+		output: "gen_ai.usage.output_tokens",
+		cacheRead: "gen_ai.usage.cache_read_tokens",
+		cacheWrite: "gen_ai.usage.cache_write_tokens",
+		totalTokens: "gen_ai.usage.total_tokens",
+		reasoning: "gen_ai.usage.reasoning_tokens"
+	})) {
+		const value = usage[field];
+		if (typeof value === "number" && Number.isFinite(value) && value >= 0) attributes[attribute] = value;
+	}
+	const cost = isRecord(usage.cost) ? usage.cost.total : void 0;
+	if (typeof cost === "number" && Number.isFinite(cost) && cost >= 0) attributes["gen_ai.usage.cost"] = cost;
+	return attributes;
+}
+function createServerTelemetry(options = {}) {
+	let active = false;
+	let finished = false;
+	let queue = Promise.resolve();
+	let disposal;
+	let thinkingLevel;
+	const sessionAttributes = (execution) => ({
+		...contextAttributes(execution),
+		...thinkingLevel ? { "pi.thinking_level": thinkingLevel } : {}
+	});
+	const enqueue = (operation) => {
+		const pending = queue.then(operation);
+		queue = pending.catch((error) => options.onDiagnostic?.(String(error)));
+		return pending;
+	};
+	let telemetry;
+	const turns = /* @__PURE__ */ new Map();
+	const tools = /* @__PURE__ */ new Map();
+	let agentStartedAt;
+	let turnIndex = 0;
+	const activity = {
+		name: PACKAGE_NAME$1,
+		start(execution) {
+			const current = createDoomTelemetry({
+				serviceName: options.serviceName ?? "pi",
+				packageName: PACKAGE_NAME$1,
+				cwd: execution.cwd,
+				env: {
+					...options.env ?? execution.environment,
+					PI_SESSION_ID: execution.sessionId
+				},
+				allowFileFallback: options.allowFileFallback,
+				telemetryFactory: options.telemetryFactory,
+				warn: options.onDiagnostic ?? (() => void 0),
+				onRecord: (record) => options.metrics?.record(record.event, record.attributes),
+				onStatus: (status) => options.onSinkStatus?.({
+					service: status.serviceName,
+					backend: status.backend,
+					endpoint: status.endpoint ?? "none",
+					endpointSource: status.endpointSource,
+					traces: status.traces,
+					redaction: true,
+					fileFallback: status.fileFallback
+				}),
+				enableLogs: true,
+				enableTraces: (options.env ?? execution.environment).AGENT_OTEL_TRACES === void 0 || isEnabled((options.env ?? execution.environment).AGENT_OTEL_TRACES)
+			});
+			telemetry = current;
+			active = true;
+			finished = false;
+			return () => disposal ??= (async () => {
+				active = false;
+				await queue;
+				if (telemetry === current) {
+					telemetry = void 0;
+					turns.clear();
+					tools.clear();
+					agentStartedAt = void 0;
+				}
+				await current.shutdown();
+			})();
+		}
+	};
+	const command = {
+		name: "log-metrics",
+		description: "Show headless telemetry sink status.",
+		async execute(_args, execution) {
+			await execution.client.notify({
+				title: "Po telemetry",
+				body: JSON.stringify(telemetry?.status() ?? { active: false }, null, 2),
+				level: "info"
+			});
+		}
+	};
+	const hooks = [
+		{
+			event: "session_start",
+			async handle(_event, execution) {
+				thinkingLevel = (await execution.session?.readModelSettings?.())?.thinkingLevel;
+				await telemetry?.recordEvent("pi.session.started", {
+					...sessionAttributes(execution),
+					"pi.session.reason": "startup",
+					"pi.session.previous": false
+				});
+			}
+		},
+		{
+			event: "agent_settled",
+			async handle(_event, execution) {
+				await telemetry?.recordDebug("pi.agent.settled", sessionAttributes(execution));
+			}
+		},
+		{
+			event: "session_shutdown",
+			async handle(_event, execution) {
+				if (finished) return;
+				finished = true;
+				await telemetry?.recordEvent("pi.session.finished", {
+					...sessionAttributes(execution),
+					"pi.session.reason": "quit"
+				});
+				execution.client.setStatus("po-log", void 0);
+			}
+		},
+		{
+			event: "turn_start",
+			async handle(event, execution) {
+				if (!telemetry) return;
+				await telemetry.recordDebug("pi.turn.started", {
+					...sessionAttributes(execution),
+					"pi.turn.index": event.turnIndex,
+					...typeof event.turnId === "string" ? { "pi.turn.id": event.turnId } : {}
+				});
+			}
+		},
+		{
+			event: "turn_end",
+			async handle(event, execution) {
+				const current = telemetry;
+				if (!current) return;
+				const duration = event.telemetryDurationMs;
+				const message = isRecord(event.message) && event.message.role === "assistant" ? event.message : void 0;
+				const usage = message === void 0 ? {} : usageAttributes(message);
+				const attributes = {
+					...sessionAttributes(execution),
+					"pi.turn.index": event.turnIndex,
+					...typeof event.turnId === "string" ? { "pi.turn.id": event.turnId } : {},
+					...message === void 0 ? {} : {
+						"gen_ai.provider.name": message.provider ?? execution.model?.provider,
+						"gen_ai.response.model": message.responseModel ?? message.model,
+						"gen_ai.response.finish_reasons": message.stopReason
+					}
+				};
+				const results = Array.isArray(event.toolResults) ? event.toolResults.filter(isRecord) : [];
+				await current.recordEvent("pi.turn.finished", {
+					...attributes,
+					...usage,
+					"pi.tool_result.count": results.length,
+					...typeof duration === "number" ? { "pi.turn.duration_ms": duration } : {}
+				});
+				if (message?.stopReason === "error" || message?.stopReason === "aborted") {
+					const failure = {
+						...attributes,
+						"error.type": "ProviderError",
+						"error.code": message.stopReason,
+						outcome: message.stopReason === "aborted" ? "aborted" : "error"
+					};
+					if (message.stopReason === "aborted") await current.recordWarning("pi.turn.failed", void 0, failure);
+					else await current.recordError("pi.turn.failed", void 0, failure);
+				}
+				if (Object.keys(usage).length > 0) for (const result of results) await current.recordDebug("pi.tool_token_sample", {
+					...attributes,
+					...usage,
+					"tool.name": result.toolName,
+					token_attribution: "toolCallTurn"
+				});
+			}
+		},
+		{
+			event: "tool_execution_start",
+			async handle(event, execution) {
+				if (!telemetry) return;
+				await telemetry.recordDebug("pi.tool_call", {
+					...sessionAttributes(execution),
+					"tool.name": event.toolName,
+					"tool.call.id": event.toolCallId
+				});
+			}
+		},
+		{
+			event: "tool_execution_end",
+			async handle(event, execution) {
+				const current = telemetry;
+				if (!current) return;
+				const duration = event.telemetryDurationMs;
+				await current.recordEvent("pi.tool_result", {
+					...sessionAttributes(execution),
+					"tool.name": event.toolName,
+					"tool.call.id": event.toolCallId,
+					success: event.isError !== true,
+					"tool.result.error": event.isError === true,
+					...typeof duration === "number" ? { "tool.duration_ms": duration } : {}
+				});
+				if (typeof event.toolCallId === "string" && event.toolCallId.startsWith("external-")) await current.flush();
+			}
+		},
+		{
+			event: "agent_start",
+			async handle(_event, execution) {
+				if (!telemetry) return;
+				await telemetry.recordEvent("pi.agent.started", sessionAttributes(execution));
+			}
+		},
+		{
+			event: "model_select",
+			async handle(event, execution) {
+				await telemetry?.recordEvent("pi.model.selected", {
+					...sessionAttributes(execution),
+					"pi.model.source": "set",
+					"gen_ai.provider.name": event.model.provider,
+					"gen_ai.request.model": event.model.id
+				});
+			}
+		},
+		{
+			event: "agent_end",
+			async handle(event, execution) {
+				await telemetry?.recordEvent("pi.agent.finished", {
+					...sessionAttributes(execution),
+					"pi.message.count": Array.isArray(event.messages) ? event.messages.length : 0,
+					...typeof event.telemetryDurationMs === "number" ? { "pi.agent.duration_ms": event.telemetryDurationMs } : {}
+				});
+				await telemetry?.flush();
+			}
+		}
+	];
+	for (const hook of hooks) {
+		const handle = hook.handle.bind(hook);
+		hook.handle = (event, execution) => {
+			if (!active) return;
+			const now = Date.now();
+			if (hook.event === "agent_start") turnIndex = 0;
+			const index = typeof event.turnIndex === "number" ? event.turnIndex : turnIndex;
+			const turnKey = typeof event.turnId === "string" ? event.turnId : String(index);
+			if (hook.event === "turn_start") turns.set(turnKey, now);
+			if (hook.event === "tool_execution_start" && typeof event.toolCallId === "string") tools.set(event.toolCallId, now);
+			if (hook.event === "agent_start") agentStartedAt = now;
+			let duration;
+			if (hook.event === "turn_end") {
+				const start = turns.get(turnKey);
+				turns.delete(turnKey);
+				turnIndex += 1;
+				if (start !== void 0) duration = now - start;
+			}
+			if (hook.event === "tool_execution_end" && typeof event.toolCallId === "string") {
+				const start = tools.get(event.toolCallId);
+				tools.delete(event.toolCallId);
+				if (start !== void 0) duration = now - start;
+			}
+			if (hook.event === "agent_end") {
+				if (agentStartedAt !== void 0) duration = now - agentStartedAt;
+				agentStartedAt = void 0;
+			}
+			return enqueue(async () => {
+				thinkingLevel = (await execution.session?.readModelSettings?.())?.thinkingLevel;
+				await handle({
+					...event,
+					turnIndex: index,
+					telemetryDurationMs: duration
+				}, execution);
+			});
+		};
+	}
+	return {
+		activities: [activity],
+		commands: [command],
+		hooks
+	};
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/_lib/serverRoot.ts
+const createLogServerRoot = () => {
+	const runtime = createServerTelemetry();
+	return {
+		value: runtime,
+		activities: runtime.activities
+	};
+};
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/root.server.ts
+var root_server_default = defineRoot(createLogServerRoot);
+//#endregion
+//#region src/services/issuesSource/index.ts
+/**
+* Agent-issue analysis over the sink's CLI.
+*
+* One transport, not two, because the daemon serves only /api/metrics and
+* /api/logs: there is no issues route to prefer. Every call is a subprocess,
+* which is why the page asks for this only when a reader opens the section
+* rather than alongside each report.
+*/
+const PACKAGE_NAME = "@agimon-ai/log-sink-mcp";
+const CLI_TIMEOUT_MS = 6e4;
+/** The analysis scans the whole window, so its output is larger than a metrics report. */
+const MAX_CLI_BUFFER = 33554432;
+function cliEntryPoint() {
+	const packageJson = createRequire(import.meta.url).resolve(`${PACKAGE_NAME}/package.json`);
+	return path.join(path.dirname(packageJson), "dist", "cli.mjs");
+}
+function runCli(params, dbPath) {
+	return new Promise((resolve, reject) => {
+		execFile(process.execPath, [
+			cliEntryPoint(),
+			"logs",
+			"agent-issues",
+			"--limit",
+			String(params.limit),
+			...params.sessionId === void 0 ? [] : ["--session-id", params.sessionId],
+			...params.startTime === void 0 ? [] : ["--start-time", params.startTime],
+			...params.endTime === void 0 ? [] : ["--end-time", params.endTime],
+			...dbPath === void 0 ? [] : ["--db-path", dbPath]
+		], {
+			timeout: CLI_TIMEOUT_MS,
+			maxBuffer: MAX_CLI_BUFFER
+		}, (error, stdout, stderr) => {
+			if (error) {
+				reject(new Error(stderr.trim() || error.message));
+				return;
+			}
+			try {
+				resolve(JSON.parse(stdout));
+			} catch {
+				reject(/* @__PURE__ */ new Error("The log sink returned output this version cannot read."));
+			}
+		});
+	});
+}
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function counts(value) {
+	if (!isRecord$1(value)) return {};
+	const entries = Object.entries(value).flatMap(([key, count]) => typeof count === "number" ? [[key, count]] : []);
+	return Object.fromEntries(entries);
+}
+function text(value) {
+	return typeof value === "string" ? value : "";
+}
+function nullableText(value) {
+	return typeof value === "string" && value !== "" ? value : null;
+}
+function toSample(value) {
+	if (!isRecord$1(value)) return [];
+	return [{
+		fingerprint: text(value.fingerprint),
+		occurrenceCount: typeof value.occurrenceCount === "number" ? value.occurrenceCount : 1,
+		category: text(value.category),
+		timestamp: text(value.timestamp),
+		level: text(value.level),
+		message: text(value.message),
+		detail: nullableText(value.detail) ?? text(value.message),
+		tool: nullableText(value.tool),
+		errorType: nullableText(value.errorType),
+		agentName: nullableText(value.agentName),
+		model: nullableText(value.model),
+		statusCode: nullableText(value.statusCode)
+	}];
+}
+/**
+* The CLI's report is a foreign process's JSON, so every field is narrowed
+* here rather than cast. A sink one version ahead may add fields, and a sink
+* one version behind may omit them; neither should throw.
+*/
+function toReport$1(raw) {
+	if (!isRecord$1(raw)) throw new Error("The log sink returned output this version cannot read.");
+	const samples = Array.isArray(raw.issues) ? raw.issues.flatMap(toSample) : [];
+	return {
+		totalIssues: typeof raw.totalIssues === "number" ? raw.totalIssues : 0,
+		uniqueIncidents: typeof raw.uniqueIncidents === "number" ? raw.uniqueIncidents : 0,
+		byCategory: counts(raw.byCategory),
+		byTool: counts(raw.byTool),
+		byErrorType: counts(raw.byErrorType),
+		samples
+	};
+}
+function createIssuesSource(options = {}) {
+	const instance = resolveLogSinkInstance({
+		env: options.env,
+		cwd: options.cwd,
+		packageName: options.packageName,
+		serviceName: options.serviceName
+	});
+	const cliRunner = options.cliRunner ?? ((params) => runCli(params, instance?.dbPath));
+	return { async query(params) {
+		return toReport$1(await cliRunner(params));
+	} };
+}
+//#endregion
+//#region src/types/webMetrics.ts
+/**
+* The dimensions the page offers.
+*
+* log-sink-mcp also groups by 'workflow-run', 'workflow-name', 'job' and
+* 'step'. Those are omitted on purpose: no Po package emits the matching
+* attributes today, so offering them would draw an empty chart and read as a
+* bug rather than as a gap.
+*/
+const METRICS_DIMENSIONS = [
+	"session",
+	"agent",
+	"model",
+	"provider"
+];
+const METRICS_PERIODS = [
+	"day",
+	"week",
+	"month",
+	"all"
+];
+const METRICS_QUERY_PARAMS = {
+	dimension: "dimension",
+	period: "period",
+	/** Narrows the whole report to one value of the current dimension. */
+	focus: "focus"
+};
+function isMetricsDimension(value) {
+	return METRICS_DIMENSIONS.includes(value);
+}
+function isMetricsPeriod(value) {
+	return METRICS_PERIODS.includes(value);
+}
+//#endregion
+//#region src/types/apiRoutes.ts
+/**
+* This package's routes, as data.
+*
+* No scope and no base path. The build reads both off
+* `src/extensions/(backend)/api/log/`, so the mount is stated once, by the
+* folder that creates it. They used to be written here, in the contract, and
+* again inside every URL the page built, and the copies were free to disagree.
+*
+* This is the one file the routes, the Hono app and the browser all read, so a
+* path cannot move on one side alone.
+*/
+var apiRoutes_default = defineApiRoutes({
+	metrics: {
+		method: "GET",
+		path: "/metrics",
+		query: [
+			METRICS_QUERY_PARAMS.dimension,
+			METRICS_QUERY_PARAMS.period,
+			METRICS_QUERY_PARAMS.focus
+		],
+		response: apiResponse()
+	},
+	/**
+	* Separate from the report because the hub answers it from a subprocess: the
+	* running daemon exposes no issues route, so folding it in would make every
+	* refresh wait on the slowest transport.
+	*/
+	issues: {
+		method: "GET",
+		path: "/issues",
+		query: [METRICS_QUERY_PARAMS.focus],
+		response: apiResponse()
+	}
+});
+//#endregion
+//#region src/services/hubApi/index.ts
+/**
+* The cockpit's half of this package's metrics access.
+*
+* Hub-scoped rather than session-scoped: the questions this answers, where the
+* tokens went and which agents failed, are about the machine over time, and a
+* session server can only see itself. The sink is already machine-wide, so the
+* hub is the only place the two agree.
+*
+* The query path is not reimplemented here. `createMetricsSource` already owns
+* the sink's two transports and its fallback order, and the TUI overlay reads
+* through the same source, so both surfaces answer from one implementation.
+*/
+const DEFAULT_DIMENSION = "model";
+const DEFAULT_PERIOD = "week";
+/** The sink groups sessions under a different name than the page's dimension. */
+const SINK_GROUP_BY = {
+	session: "session",
+	agent: "agent",
+	model: "model",
+	provider: "provider"
+};
+function toBucket(bucket) {
+	return {
+		label: bucket.label,
+		totalTokens: bucket.totalTokens,
+		inputTokens: bucket.inputTokens,
+		outputTokens: bucket.outputTokens
+	};
+}
+function toGroup(row) {
+	return {
+		key: row.key,
+		totalTokens: row.totalTokens,
+		inputTokens: row.inputTokens,
+		outputTokens: row.outputTokens,
+		issueCount: row.issueCount,
+		failed: row.failed
+	};
+}
+/**
+* The turn's p90 rather than a sum: the sink attributes a whole turn's tokens
+* to every tool that ran in it, so adding them across calls would multiply the
+* same tokens by however many tools shared the turn.
+*/
+function toTool(row) {
+	return {
+		name: row.toolName,
+		calls: row.invocationCount,
+		p90TotalTokens: row.toolCallTurn.p90TotalTokens
+	};
+}
+/** Which filter field carries a focus value, per dimension. */
+const FOCUS_FIELD = {
+	session: "sessionId",
+	agent: "agentName",
+	model: "model",
+	provider: "provider"
+};
+/**
+* The focus the sink actually applied, read from its own echo.
+*
+* A daemon that predates a filter ignores it and answers with everything. If
+* the page trusted the request instead of this echo, it would label the whole
+* machine's numbers as one model's.
+*/
+function appliedFocus(report, dimension) {
+	const filters = report.filters;
+	if (filters === void 0) return void 0;
+	if (dimension === "session") return filters.sessionId;
+	if (dimension === "agent") return filters.agentName;
+	const applied = dimension === "model" ? filters.model : filters.provider;
+	if (applied === void 0) return void 0;
+	return Array.isArray(applied) ? applied[0] : applied;
+}
+/**
+* The sink's own type says Date, but both transports parse JSON, so what
+* arrives is an ISO string. Trusting the declared type here throws on every
+* real response, which no test using a hand-built Date would ever catch.
+*/
+function generatedAtIso(value) {
+	if (value instanceof Date) return value.toISOString();
+	const parsed = new Date(value);
+	return Number.isNaN(parsed.getTime()) ? (/* @__PURE__ */ new Date(0)).toISOString() : parsed.toISOString();
+}
+function toReport(report, source, dimension) {
+	const focus = appliedFocus(report, dimension);
+	return {
+		generatedAt: generatedAtIso(report.generatedAt),
+		...report.filters?.startTime === void 0 ? {} : { startTime: generatedAtIso(report.filters.startTime) },
+		endTime: generatedAtIso(report.filters?.endTime ?? report.generatedAt),
+		dimension: report.groupBy,
+		period: report.period,
+		bucketUnit: String(report.bucket),
+		transport: source.lastTransport(),
+		...focus === void 0 ? {} : { focus },
+		totals: {
+			usageEventCount: report.totals.usageEventCount,
+			totalRecords: report.totals.totalRecords,
+			totalTokens: report.totals.totalTokens,
+			inputTokens: report.totals.inputTokens,
+			outputTokens: report.totals.outputTokens,
+			cachedTokens: report.totals.cachedInputTokens,
+			reasoningTokens: report.totals.reasoningOutputTokens,
+			groupCount: report.totals.groupCount,
+			failedGroups: report.totals.failedGroups,
+			issueCount: report.totals.issueCount
+		},
+		timeline: report.timeline.map(toBucket),
+		groups: report.groups.map(toGroup),
+		tools: report.tools.rows.map(toTool)
+	};
+}
+/**
+* A report with nothing in it reads as "no data", not as an empty chart. The
+* reader may have used the HTTP sink or a worker against an empty history, so
+* the empty-state detail must not claim the sink is running.
+*/
+function isEmpty(report) {
+	return report.totals.totalTokens === 0 && report.groups.length === 0 && report.tools.length === 0;
+}
+function createLogHubApi(options = {}) {
+	const app = new Hono();
+	const identity = {
+		packageName: PACKAGE_NAME$1,
+		serviceName: "pi",
+		...options.env === void 0 ? {} : { env: options.env }
+	};
+	const source = options.source ?? createMetricsSource(identity);
+	const issues = options.issues ?? createIssuesSource(identity);
+	app.get(apiRoutes_default.metrics.path, async (context) => {
+		const requestedDimension = context.req.query(METRICS_QUERY_PARAMS.dimension) ?? DEFAULT_DIMENSION;
+		const requestedPeriod = context.req.query(METRICS_QUERY_PARAMS.period) ?? DEFAULT_PERIOD;
+		if (!isMetricsDimension(requestedDimension)) return context.json({ error: `Unknown dimension '${requestedDimension}'.` }, 400);
+		if (!isMetricsPeriod(requestedPeriod)) return context.json({ error: `Unknown period '${requestedPeriod}'.` }, 400);
+		const focus = context.req.query(METRICS_QUERY_PARAMS.focus);
+		const filter = focus === void 0 || focus === "" ? void 0 : { [FOCUS_FIELD[requestedDimension]]: focus };
+		let report;
+		try {
+			report = await source.query({
+				groupBy: SINK_GROUP_BY[requestedDimension],
+				period: requestedPeriod,
+				limit: 20,
+				toolLimit: 15,
+				...filter === void 0 ? {} : { filter }
+			});
+		} catch (error) {
+			const unavailable = {
+				unavailable: "query-error",
+				detail: error instanceof Error ? error.message : "The metrics query failed."
+			};
+			return context.json(unavailable);
+		}
+		const body = toReport(report, source, requestedDimension);
+		if (isEmpty(body)) return context.json({
+			unavailable: "no-data",
+			detail: "No recorded usage was found for this period."
+		});
+		return context.json(body);
+	});
+	/**
+	* The detail behind the count the report carries. Separate from /metrics
+	* because it costs a subprocess: the running daemon has no issues route, so
+	* folding it into every report would make the whole page as slow as its
+	* slowest transport.
+	*/
+	app.get(apiRoutes_default.issues.path, async (context) => {
+		const focus = context.req.query(METRICS_QUERY_PARAMS.focus);
+		const startTime = context.req.query("startTime");
+		const endTime = context.req.query("endTime");
+		const validTime = (value) => value === void 0 || /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && Number.isFinite(Date.parse(value));
+		if (!validTime(startTime) || !validTime(endTime) || startTime !== void 0 && endTime !== void 0 && Date.parse(startTime) > Date.parse(endTime)) return context.json({ error: "Issue time bounds must be valid ISO instants in chronological order." }, 400);
+		try {
+			const report = await issues.query({
+				limit: 50,
+				...startTime === void 0 ? {} : { startTime },
+				...endTime === void 0 ? {} : { endTime },
+				...focus === void 0 || focus === "" ? {} : { sessionId: focus }
+			});
+			return context.json(report);
+		} catch (error) {
+			const unavailable = {
+				unavailable: "query-error",
+				detail: error instanceof Error ? error.message : "The issues query failed."
+			};
+			return context.json(unavailable);
+		}
+	});
+	return app;
+}
+//#endregion
+//#region src/extensions/(backend)/api/log/route.server.ts
+var route_server_default = defineRoute({
+	basePath: "log",
+	start(context) {
+		const env = { ...context.environment };
+		const source = createMetricsSource({
+			env,
+			packageName: PACKAGE_NAME$1,
+			serviceName: "pi"
+		});
+		const app = createLogHubApi({
+			source,
+			env
+		});
+		return {
+			fetch: (request) => app.fetch(request),
+			close: () => source.close?.()
+		};
+	}
+});
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/command/log-metrics.server.ts
+var log_metrics_server_default = defineServerCommand((context) => context.root.commands[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-end.server.ts
+var agent_end_server_default = defineHook((context) => context.root.hooks[9]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-settled.server.ts
+var agent_settled_server_default = defineHook((context) => context.root.hooks[1]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/agent-start.server.ts
+var agent_start_server_default = defineHook((context) => context.root.hooks[7]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/model-select.server.ts
+var model_select_server_default = defineHook((context) => context.root.hooks[8]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-shutdown.server.ts
+var session_shutdown_server_default = defineHook((context) => context.root.hooks[2]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/session-start.server.ts
+var session_start_server_default = defineHook((context) => context.root.hooks[0]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-end.server.ts
+var tool_execution_end_server_default = defineHook((context) => context.root.hooks[6]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/tool-execution-start.server.ts
+var tool_execution_start_server_default = defineHook((context) => context.root.hooks[5]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/turn-end.server.ts
+var turn_end_server_default = defineHook((context) => context.root.hooks[4]);
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/hook/turn-start.server.ts
+var turn_start_server_default = defineHook((context) => context.root.hooks[3]);
+//#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.";
+const AGENT_DIAGNOSTIC_TIMEOUT_MS = 15e3;
+const AGENT_ISSUE_CATEGORIES = [
+	"tool_failure",
+	"infrastructure_failure",
+	"caller_error",
+	"expected_failure",
+	"page_state",
+	"api_error",
+	"api_refusal",
+	"api_retries_exhausted",
+	"tool_rejected",
+	"log_error"
+];
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/resource/po-debug-agent.server.ts
+var po_debug_agent_server_default = defineResource({
+	name: "po-debug-agent",
+	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: DOOM_HELP_WHEN,
+	kind: "skill",
+	path: packageResourcePath(import.meta.url, "src/prompts/po-debug-agent/SKILL.md"),
+	read: () => readPackageResource(import.meta.url, "src/prompts/po-debug-agent/SKILL.md")
+});
+//#endregion
+//#region src/schemas/agentDiagnostics.ts
+const count = Type.Number({ minimum: 0 });
+const coverage = Type.Number({
+	minimum: 0,
+	maximum: 100
+});
+const agentDiagnosticParameters = Type.Object({
+	period: Type.Optional(Type.Union([Type.Literal("day"), Type.Literal("week")])),
+	toolLimit: Type.Optional(Type.Integer({
+		minimum: 1,
+		maximum: 20
+	}))
+}, { additionalProperties: false });
+/** Validate only the fields we return. Extra upstream fields never cross this boundary. */
+const scopedMetricsSchema = Type.Object({
+	groupBy: Type.Literal("session"),
+	period: Type.Union([Type.Literal("day"), Type.Literal("week")]),
+	filters: Type.Object({ sessionId: Type.String({ minLength: 1 }) }),
+	totals: Type.Object({
+		totalRecords: count,
+		issueCount: count,
+		usageEventCount: count,
+		inputTokens: count,
+		outputTokens: count,
+		totalTokens: count,
+		cachedInputTokens: count,
+		reasoningOutputTokens: count,
+		tokenCoveragePercent: coverage
+	}),
+	groups: Type.Array(Type.Object({
+		sessionId: Type.String({ minLength: 1 }),
+		byCategory: Type.Record(Type.String(), count)
+	}), { maxItems: 1 }),
+	tools: Type.Object({
+		returnedTools: count,
+		rows: Type.Array(Type.Object({
+			toolName: Type.String({
+				minLength: 1,
+				maxLength: 128,
+				pattern: "^[A-Za-z0-9_./:-]+$"
+			}),
+			invocationCount: count,
+			toolCallTurn: Type.Object({
+				samples: count,
+				avgTotalTokens: count,
+				p90TotalTokens: count
+			})
+		}), { maxItems: 20 })
+	})
+});
+//#endregion
+//#region src/services/agentDiagnostics/index.ts
+async function readAgentDiagnostics(source, sessionId, input, signal) {
+	const period = input.period ?? "day";
+	const limit = input.toolLimit ?? 10;
+	signal.throwIfAborted();
+	let onAbort = () => {};
+	try {
+		const report = await Promise.race([source.query({
+			groupBy: "session",
+			period,
+			limit: 1,
+			toolLimit: limit,
+			filter: { sessionId }
+		}), new Promise((_resolve, reject) => {
+			onAbort = () => reject(signal.reason);
+			signal.addEventListener("abort", onAbort, { once: true });
+			if (signal.aborted) onAbort();
+		})]);
+		signal.throwIfAborted();
+		if (!Check(scopedMetricsSchema, report) || report.filters.sessionId !== sessionId || report.period !== period || report.groups.some((group) => group.sessionId !== sessionId)) return {
+			evidence: "unavailable",
+			code: "METRICS_SCOPE_NOT_CONFIRMED",
+			scope: "current-session",
+			period
+		};
+		const totals = report.totals;
+		return {
+			scope: "current-session",
+			period,
+			evidence: totals.totalRecords === 0 ? "empty" : "available",
+			transport: source.lastTransport(),
+			capturedRecords: totals.totalRecords,
+			capturedIssues: totals.issueCount,
+			issuesByCategory: Object.fromEntries(AGENT_ISSUE_CATEGORIES.map((category) => [category, report.groups[0]?.byCategory[category] ?? 0])),
+			usage: {
+				inputTokens: totals.inputTokens,
+				outputTokens: totals.outputTokens,
+				totalTokens: totals.totalTokens,
+				cachedInputTokens: totals.cachedInputTokens,
+				reasoningOutputTokens: totals.reasoningOutputTokens,
+				usageEventCount: totals.usageEventCount,
+				tokenCoveragePercent: totals.tokenCoveragePercent
+			},
+			tools: report.tools.rows.slice(0, limit).map((tool) => ({
+				name: tool.toolName,
+				invocations: tool.invocationCount,
+				sampledTurns: tool.toolCallTurn.samples,
+				averageTurnTokens: tool.toolCallTurn.avgTotalTokens,
+				p90TurnTokens: tool.toolCallTurn.p90TotalTokens
+			})),
+			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."
+		};
+	} catch (error) {
+		if (signal.aborted) throw error;
+		return {
+			evidence: "unavailable",
+			code: "METRICS_UNAVAILABLE",
+			scope: "current-session",
+			period
+		};
+	} finally {
+		signal.removeEventListener("abort", onAbort);
+	}
+}
+function createAgentDiagnosticsTool(readScope, authorize) {
+	return defineTool({
+		name: DIAGNOSE_AGENT_NAME,
+		description: DIAGNOSE_AGENT_DESCRIPTION,
+		parameters: agentDiagnosticParameters,
+		when: DOOM_HELP_WHEN,
+		executionMode: "serial",
+		async execute(input, execution) {
+			const active = authorize(execution.signal);
+			const signal = AbortSignal.any([active, AbortSignal.timeout(AGENT_DIAGNOSTIC_TIMEOUT_MS)]);
+			const scope = readScope();
+			if (!scope.sessionId) throw new Error("Agent diagnostics require an active session.");
+			const source = createMetricsSource({
+				packageName: PACKAGE_NAME$1,
+				serviceName: "pi",
+				...scope.options
+			});
+			try {
+				const report = await readAgentDiagnostics(source, scope.sessionId, input, signal);
+				signal.throwIfAborted();
+				authorize(execution.signal);
+				return {
+					content: [{
+						type: "text",
+						text: JSON.stringify(report, null, 2)
+					}],
+					details: report
+				};
+			} finally {
+				await source.close?.();
+			}
+		}
+	});
+}
+//#endregion
+//#region src/extensions/workspaces/sessions/(backend)/tool/diagnose_agent.server.ts
+var diagnose_agent_server_default = defineTool$1(({ agent, signal: ownerSignal }) => {
+	if (!agent) throw new Error("Agent diagnostics require a session host.");
+	return createAgentDiagnosticsTool(() => ({
+		sessionId: agent.context.sessionId,
+		options: {
+			cwd: agent.context.cwd,
+			env: {
+				...agent.context.environment,
+				PI_SESSION_ID: agent.context.sessionId
+			}
+		}
+	}), (signal) => {
+		ownerSignal.throwIfAborted();
+		signal?.throwIfAborted();
+		agent.assertActive(PACKAGE_NAME$1);
+		if (!(agent.context.selection.state?.["minor-mode"] ?? []).includes("help")) throw new Error("Help mode is not active.");
+		return signal ? AbortSignal.any([signal, ownerSignal]) : ownerSignal;
+	});
+});
+//#endregion
+//#region generated/server.ts
+const at = (value, context) => typeof value === "function" ? value(context) : value;
+const via = (identity, value) => value === void 0 ? void 0 : {
+	...identity,
+	...value
+};
+const facet = defineServerPlugin({
+	name: "@agimon-ai/po-log",
+	providerOverrides: composeServerProviderOverrides(root_server_default),
+	global: (context) => ({ get api() {
+		return [at(route_server_default, context)];
+	} }),
+	workspace: (context) => ({ get api() {
+		return [at(route_server_default, context)];
+	} }),
+	session: async (context) => {
+		const scopeSession = await root_server_default(context);
+		const contextSession = {
+			...context,
+			root: scopeSession.value
+		};
+		return {
+			...composeRootHooks(scopeSession),
+			get api() {
+				return [at(route_server_default, context)];
+			},
+			get commands() {
+				return [via({ name: "log-metrics" }, at(log_metrics_server_default, contextSession))];
+			},
+			get hooks() {
+				return [
+					via({ event: "agent_end" }, at(agent_end_server_default, contextSession)),
+					via({ event: "agent_settled" }, at(agent_settled_server_default, contextSession)),
+					via({ event: "agent_start" }, at(agent_start_server_default, contextSession)),
+					via({ event: "model_select" }, at(model_select_server_default, contextSession)),
+					via({ event: "session_shutdown" }, at(session_shutdown_server_default, contextSession)),
+					via({ event: "session_start" }, at(session_start_server_default, contextSession)),
+					via({ event: "tool_execution_end" }, at(tool_execution_end_server_default, contextSession)),
+					via({ event: "tool_execution_start" }, at(tool_execution_start_server_default, contextSession)),
+					via({ event: "turn_end" }, at(turn_end_server_default, contextSession)),
+					via({ event: "turn_start" }, at(turn_start_server_default, contextSession))
+				];
+			},
+			get resources() {
+				return [at(po_debug_agent_server_default, contextSession)];
+			},
+			get tools() {
+				return [via({ name: "diagnose_agent" }, at(diagnose_agent_server_default, contextSession))];
+			},
+			services: [...scopeSession.services ?? []],
+			get activities() {
+				return [...scopeSession.activities ?? []];
+			}
+		};
+	}
+});
+//#endregion
+export { facet as default, facet };
+
+//# sourceMappingURL=server.mjs.map