@xopcai/xopc 0.0.171 → 0.0.173

package/dist/src/connectors/learning-coordinator.d.ts

@@ -0,0 +1,25 @@
+import type { Config } from '../config/schema.js';
+import type { MemoryManager } from '../agent/memory/manager.js';
+import { type ConnectorLearningJob } from '../storage/sqlite/index.js';
+import { ComposioSessionsAdapter } from './composio-sessions.js';
+export type ConnectorLearningCoordinator = {
+    enqueueConnection(connectionId: string, request?: {
+        mode?: 'bootstrap' | 'incremental';
+        reason?: 'manual' | 'event' | 'schedule';
+        idempotencyKey?: string;
+        nextRunAt?: number;
+    }): ConnectorLearningJob | null;
+    enqueueToolkit(toolkit: string): ConnectorLearningJob[];
+    setPaused(connectionId: string, paused: boolean): number;
+    runNow(): Promise<void>;
+    stop(): void;
+};
+export declare function startConnectorLearningCoordinator(options: {
+    getConfig: () => Config;
+    resolveAgentId: () => string;
+    getMemoryManager: () => MemoryManager;
+    emit?: (type: string, payload: unknown) => void;
+    intervalMs?: number;
+    initialDelayMs?: number;
+    composioAdapter?: ComposioSessionsAdapter;
+}): ConnectorLearningCoordinator;

package/dist/src/connectors/learning-coordinator.js

@@ -0,0 +1,214 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "../storage/sqlite/connector-learning-repository.js";
+import { pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { getConnectorDefinition } from "./catalog.js";
+import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
+import "../knowledge/index.js";
+import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
+import { normalizeConnectorIdentity } from "./connector-identity.js";
+import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
+//#region src/connectors/learning-coordinator.ts
+init_logger();
+const log = createLogger("ConnectorLearning");
+const CONNECTED_ACCOUNT_UNAVAILABLE = "connected_account_unavailable";
+const CONNECTED_SOURCE_SYNC_FAILED = "connected_source_sync_failed";
+function learningFailureCode(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("ToolRouterV2_InvalidConnectedAccountIds") || message.includes("Could not find connected account(s)") || message.includes("missing its provider identity") ? CONNECTED_ACCOUNT_UNAVAILABLE : CONNECTED_SOURCE_SYNC_FAILED;
+}
+function learningEnabled(config) {
+	return config.userContext.enabled && config.userContext.understanding.enabled && config.userContext.memory.mode !== "off" && config.userContext.memory.sources.includes("connectedSources");
+}
+function startConnectorLearningCoordinator(options) {
+	const intervalMs = Math.max(2e3, Math.min(options.intervalMs ?? 1e4, 6e4));
+	let timer = null;
+	let running = false;
+	let stopped = false;
+	const composioAdapter = options.composioAdapter ?? new ComposioSessionsAdapter();
+	const publish = (job) => options.emit?.("connector.learning.updated", job);
+	function enqueueConnection(connectionId, request = {}) {
+		if (!learningEnabled(options.getConfig())) return null;
+		const connection = listConnectorConnections().find((item) => item.id === connectionId && item.status === "active");
+		if (!connection) return null;
+		const definition = getConnectorDefinition(connection.connectorId);
+		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") return null;
+		if (!getConnectorLearningPlan(definition.runtime.toolkit)) return null;
+		const sourceInstanceId = `composio:${connection.connectorId}:${connection.id}`;
+		const existing = listConnectorLearningJobs({
+			connectionId: connection.id,
+			limit: 1
+		});
+		const mode = request.mode ?? (existing.length === 0 ? "bootstrap" : "incremental");
+		const bucket = Math.floor(Date.now() / 6e4);
+		const job = enqueueConnectorLearningJob({
+			connectorId: connection.connectorId,
+			connectionId: connection.id,
+			sourceInstanceId,
+			agentId: options.resolveAgentId(),
+			mode,
+			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.id}:v1` : `incremental:${connection.id}:${request.reason ?? "manual"}:${bucket}`),
+			nextRunAt: request.nextRunAt
+		});
+		publish(job);
+		queueMicrotask(() => void runNow());
+		return job;
+	}
+	function enqueueToolkit(toolkit) {
+		const normalized = toolkit.trim().toLowerCase();
+		return listConnectorConnections().filter((connection) => connection.status === "active").filter((connection) => {
+			const definition = getConnectorDefinition(connection.connectorId);
+			return definition?.runtime.type === "composio" && definition.runtime.role === "toolkit" && definition.runtime.toolkit === normalized;
+		}).map((connection) => enqueueConnection(connection.id, { reason: "event" })).filter((job) => Boolean(job));
+	}
+	async function execute(job) {
+		publish(job);
+		const definition = getConnectorDefinition(job.connectorId);
+		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector learning is unavailable for ${job.connectorId}.`);
+		const plan = getConnectorLearningPlan(definition.runtime.toolkit);
+		if (!plan) throw new Error(`Connector learning has no plan for ${definition.runtime.toolkit}.`);
+		let connection = listConnectorConnections().find((candidate) => candidate.id === job.connectionId);
+		if (!connection) throw new Error("Connector account no longer exists.");
+		const installation = getConnectorInstallation(`${job.connectorId}-local-owner`);
+		if (!installation?.enabled) throw new Error("Connector installation is not enabled.");
+		const hasIdentity = Object.values(connection.identity).some((value) => typeof value === "string" && value.trim());
+		if (plan.identityProbe && (job.mode === "bootstrap" || !hasIdentity)) {
+			const execution = await composioAdapter.executeWithPolicy({
+				context: {
+					principalId: connection.principalId,
+					toolkits: [plan.toolkit]
+				},
+				installation: {
+					...installation,
+					maxScope: "read",
+					confirmationPolicy: "never"
+				},
+				connection,
+				agentId: job.agentId,
+				action: {
+					connectorId: job.connectorId,
+					actionId: plan.identityProbe.actionId,
+					toolkit: plan.toolkit,
+					scope: "read",
+					curated: true,
+					cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+				},
+				args: {},
+				confirmed: true
+			});
+			if (execution.decision !== "allowed") throw new Error(execution.reason);
+			connection = upsertConnectorConnection({
+				...connection,
+				identity: normalizeConnectorIdentity(plan.toolkit, execution.result)
+			});
+		}
+		let itemsSeen = 0;
+		let itemsIndexed = 0;
+		for (const stream of plan.streams) {
+			const synced = await ingestComposioConnectedSource({
+				config: options.getConfig(),
+				connectorId: job.connectorId,
+				connectionId: job.connectionId,
+				collectionScope: stream.scope,
+				streamKind: stream.kind,
+				actionId: stream.actionId,
+				arguments: stream.arguments,
+				buildArguments: (pull) => buildConnectorLearningArguments(plan, stream, pull, connection.identity),
+				agentId: job.agentId
+			});
+			itemsSeen += synced.itemsSeen;
+			itemsIndexed += synced.itemsIndexed;
+		}
+		if (listConnectorLearningJobs({
+			connectionId: job.connectionId,
+			limit: 100
+		}).find((candidate) => candidate.id === job.id)?.status === "paused") return;
+		publish(updateConnectorLearningJob(job.id, {
+			phase: "indexing",
+			itemsDiscovered: itemsSeen,
+			itemsIndexed
+		}));
+		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
+		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
+		publish(updateConnectorLearningJob(job.id, {
+			status: "completed",
+			phase: "completed",
+			candidatesCreated: understanding.created,
+			nextRunAt: null,
+			finished: true
+		}));
+		pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
+		const nextRunAt = Date.now() + plan.intervalMinutes * 6e4;
+		enqueueConnection(job.connectionId, {
+			mode: "incremental",
+			reason: "schedule",
+			nextRunAt,
+			idempotencyKey: `scheduled:${job.connectionId}:${nextRunAt}`
+		});
+	}
+	async function runNow() {
+		if (running || stopped) return;
+		running = true;
+		try {
+			for (let count = 0; count < 10; count += 1) {
+				const job = claimNextConnectorLearningJob();
+				if (!job) break;
+				try {
+					await execute(job);
+				} catch (err) {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					const exhausted = job.attemptCount >= 5;
+					publish(updateConnectorLearningJob(job.id, {
+						status: exhausted ? "paused" : "failed",
+						error: learningFailureCode(err),
+						nextRunAt: exhausted ? null : Date.now() + Math.min(30 * 6e4, 3e4 * 2 ** Math.min(job.attemptCount, 6)),
+						finished: true
+					}));
+					log.warn({
+						err,
+						jobId: job.id,
+						connectorId: job.connectorId
+					}, `Connector learning failed: ${errorMessage}`);
+				}
+			}
+		} finally {
+			running = false;
+		}
+	}
+	recoverStaleConnectorLearningJobs(Date.now());
+	if (learningEnabled(options.getConfig())) {
+		for (const connection of listConnectorConnections().filter((item) => item.status === "active")) if (listConnectorLearningJobs({
+			connectionId: connection.id,
+			limit: 1
+		}).length === 0) enqueueConnection(connection.id, { reason: "schedule" });
+	}
+	timer = setTimeout(() => {
+		runNow();
+		timer = setInterval(() => void runNow(), intervalMs);
+		timer.unref?.();
+	}, Math.max(0, options.initialDelayMs ?? 2e3));
+	timer.unref?.();
+	return {
+		enqueueConnection,
+		enqueueToolkit,
+		setPaused(connectionId, paused) {
+			const changed = setConnectorLearningPaused(connectionId, paused);
+			if (!paused && changed > 0) queueMicrotask(() => void runNow());
+			return changed;
+		},
+		runNow,
+		stop() {
+			stopped = true;
+			if (timer) {
+				clearTimeout(timer);
+				clearInterval(timer);
+				timer = null;
+			}
+		}
+	};
+}
+//#endregion
+export { startConnectorLearningCoordinator };

package/dist/src/connectors/learning-recipes.d.ts

@@ -0,0 +1,22 @@
+export type ConnectorIdentityProbe = {
+    actionId: string;
+};
+export type ConnectorLearningStream = {
+    scope: string;
+    actionId: string;
+    arguments: Record<string, unknown>;
+    kind: 'activity' | 'inventory';
+};
+export type ConnectorLearningPlan = {
+    toolkit: string;
+    identityProbe?: ConnectorIdentityProbe;
+    streams: ConnectorLearningStream[];
+    bootstrapWindowDays: number;
+    intervalMinutes: number;
+};
+export declare function buildConnectorLearningArguments(plan: ConnectorLearningPlan, stream: ConnectorLearningStream, input: {
+    cursor?: string;
+    windowStart?: string;
+}, identity: Record<string, unknown>): Record<string, unknown>;
+export declare function getConnectorLearningPlan(toolkit: string): ConnectorLearningPlan | undefined;
+export declare function listConnectorLearningPlans(): ConnectorLearningPlan[];

package/dist/src/connectors/learning-recipes.js

@@ -0,0 +1,121 @@
+//#region src/connectors/learning-recipes.ts
+function buildConnectorLearningArguments(plan, stream, input, identity) {
+	if (plan.toolkit === "github" && stream.scope === "authored-work") {
+		const username = typeof identity.username === "string" ? identity.username.trim() : "";
+		if (!username) throw new Error("GitHub activity sync requires the authenticated username.");
+		return {
+			...stream.arguments,
+			q: `author:${username} sort:updated-desc`
+		};
+	}
+	if (!input.cursor) return { ...stream.arguments };
+	if (plan.toolkit === "gmail") {
+		const after = Math.floor(Date.parse(input.cursor) / 1e3);
+		return Number.isFinite(after) ? {
+			...stream.arguments,
+			query: `after:${after} -in:spam -in:trash`
+		} : { ...stream.arguments };
+	}
+	if (plan.toolkit === "googlecalendar") return {
+		...stream.arguments,
+		time_min: input.cursor
+	};
+	return { ...stream.arguments };
+}
+const PLANS = {
+	gmail: {
+		toolkit: "gmail",
+		identityProbe: { actionId: "GMAIL_GET_PROFILE" },
+		streams: [{
+			scope: "messages",
+			actionId: "GMAIL_FETCH_EMAILS",
+			kind: "activity",
+			arguments: {
+				max_results: 100,
+				query: "newer_than:30d -in:spam -in:trash"
+			}
+		}],
+		bootstrapWindowDays: 30,
+		intervalMinutes: 15
+	},
+	googlecalendar: {
+		toolkit: "googlecalendar",
+		streams: [{
+			scope: "events",
+			actionId: "GOOGLECALENDAR_LIST_EVENTS",
+			kind: "activity",
+			arguments: { max_results: 200 }
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 15
+	},
+	googledrive: {
+		toolkit: "googledrive",
+		streams: [{
+			scope: "files",
+			actionId: "GOOGLEDRIVE_SEARCH_FILES",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	notion: {
+		toolkit: "notion",
+		streams: [{
+			scope: "pages",
+			actionId: "NOTION_SEARCH",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	slack: {
+		toolkit: "slack",
+		streams: [{
+			scope: "channels",
+			actionId: "SLACK_LIST_CHANNELS",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 30,
+		intervalMinutes: 15
+	},
+	github: {
+		toolkit: "github",
+		identityProbe: { actionId: "GITHUB_GET_THE_AUTHENTICATED_USER" },
+		streams: [{
+			scope: "repositories",
+			actionId: "GITHUB_LIST_REPOSITORIES_FOR_THE_AUTHENTICATED_USER",
+			kind: "inventory",
+			arguments: {}
+		}, {
+			scope: "authored-work",
+			actionId: "GITHUB_SEARCH_ISSUES_AND_PULL_REQUESTS",
+			kind: "activity",
+			arguments: { per_page: 100 }
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	linear: {
+		toolkit: "linear",
+		streams: [{
+			scope: "issues",
+			actionId: "LINEAR_LIST_ISSUES",
+			kind: "activity",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 60,
+		intervalMinutes: 15
+	}
+};
+function getConnectorLearningPlan(toolkit) {
+	return PLANS[toolkit.trim().toLowerCase()];
+}
+function listConnectorLearningPlans() {
+	return Object.values(PLANS);
+}
+//#endregion
+export { buildConnectorLearningArguments, getConnectorLearningPlan, listConnectorLearningPlans };

package/dist/src/connectors/runtime-status.d.ts

@@ -1,9 +1,2 @@
 import type { ConnectorConnection, ConnectorInstance } from './types.js';
-export type ComposioRuntimeProbe = {
-    connectorId: string;
-    checkedAt: string;
-    toolCount?: number;
-    error?: string;
-    connectionError?: boolean;
-};
-export declare function projectComposioRuntimeStatus(instances: ConnectorInstance[], connections: ConnectorConnection[], probes: ComposioRuntimeProbe[]): ConnectorInstance[];
+export declare function projectComposioConnectionStatus(instances: ConnectorInstance[], connections: ConnectorConnection[]): ConnectorInstance[];

package/dist/src/connectors/runtime-status.js

@@ -1,43 +1,18 @@
 //#region src/connectors/runtime-status.ts
-function projectComposioRuntimeStatus(instances, connections, probes) {
-	const probeByConnectorId = new Map(probes.map((probe) => [probe.connectorId, probe]));
+function projectComposioConnectionStatus(instances, connections) {
 	return instances.map((instance) => {
 		if (instance.materialized.type !== "composio" || instance.materialized.role !== "toolkit" || !instance.enabled) return instance;
 		const relevant = connections.filter((connection) => connection.provider === "composio" && connection.connectorId === instance.connectorId && connection.status !== "revoked");
 		const active = relevant.filter((connection) => connection.status === "active");
-		const probe = probeByConnectorId.get(instance.connectorId);
 		const lastConnectedAt = active.flatMap((connection) => connection.connectedAt ? [connection.connectedAt] : []).sort().at(-1) ?? instance.lastConnectedAt;
-		if (active.length > 0 && probe && !probe.error && (probe.toolCount ?? 0) > 0) return {
+		if (active.length > 0) return {
 			...instance,
 			status: "connected",
 			connectionStatus: "connected",
 			authStatus: "connected",
 			lastConnectedAt,
-			lastError: void 0,
-			usage: {
-				...instance.usage,
-				lastHealthCheckAt: probe.checkedAt,
-				lastHealthStatus: "ok",
-				lastToolCount: probe.toolCount
-			}
+			lastError: void 0
 		};
-		if (active.length > 0 && probe) {
-			const error = probe.error ?? "The connection did not expose any usable tools.";
-			return {
-				...instance,
-				status: "degraded",
-				connectionStatus: probe.connectionError ? "error" : "connected",
-				authStatus: "connected",
-				lastConnectedAt,
-				lastError: error,
-				usage: {
-					...instance.usage,
-					lastHealthCheckAt: probe.checkedAt,
-					lastHealthStatus: probe.connectionError ? "network_failed" : "tools_list_failed",
-					lastToolCount: probe.toolCount ?? 0
-				}
-			};
-		}
 		if (relevant.some((connection) => connection.status === "pending")) return {
 			...instance,
 			status: "connecting",
@@ -65,4 +40,4 @@ function projectComposioRuntimeStatus(instances, connections, probes) {
 	});
 }
 //#endregion
-export { projectComposioRuntimeStatus };
+export { projectComposioConnectionStatus };

package/dist/src/extensions/api.js

@@ -1,11 +1,11 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { registerSpeechProvider } from "../voice/tts/speech-registry.js";
 import { HOOK_EXECUTION_MODES } from "./types/hooks.js";
 import { commandRegistry } from "../chat-commands/registry.js";
 import { TypedEventBus } from "./typed-event-bus.js";
 import { ExtensionRegistryImpl } from "./extension-registry-impl.js";
-import { registerMarketplaceAdapter, unregisterMarketplaceAdapter } from "../agent/skills/marketplace/registry.js";
 import { registerMediaUnderstandingProvider } from "../media-understanding/registry.js";
 import { registerMigration } from "../migrations/registry.js";
 import { isAbsolute, resolve } from "path";

package/dist/src/extensions/install.js

@@ -2,8 +2,8 @@ import { PACKAGE_VERSION, init_package_version } from "../package-version.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { init_paths, resolveBundledExtensionsDir, resolveExtensionsDir as resolveExtensionsDir$1 } from "../config/paths.js";
-import { checkEngineCompatibility } from "./engine-check.js";
 import { MAX_EXTENSION_STORE_ZIP_BYTES } from "./store-zip-limits.js";
+import { checkEngineCompatibility } from "./engine-check.js";
 import { collectExtensionPackageDependencyIssues } from "./package-contract.js";
 import { dirname, isAbsolute, join, resolve, sep } from "path";
 import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from "fs";

package/dist/src/gateway/agent-builtin-tools.d.ts

@@ -2,5 +2,5 @@
  * Built-in agent tool `name` values for gateway admin UI (disable toggles).
  * Extension tools are not listed; users can still add arbitrary strings in config.
  */
-export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["code_search", "code_read_symbol", "code_trace", "code_impact", "code_architecture", "read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "curated_memory", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "extensions", "bundle-mcp"];
+export declare const GATEWAY_BUILTIN_TOOL_IDS: readonly ["code_search", "code_read_symbol", "code_trace", "code_impact", "code_architecture", "read_file", "write_file", "apply_patch", "list_dir", "grep", "find", "exec_command", "update_plan", "session_status", "dreaming", "tool_manual", "clarify", "todo", "skills_list", "skill_view", "skill_manage", "skills_marketplace_search", "skill_install", "web_search", "web_fetch", "web_extract", "send_message", "send_media", "read_media", "create_share", "text_to_speech", "memory_search", "memory_get", "curated_memory", "session_search", "automation", "workflow", "delegate_task", "execute_code", "image", "image_generate", "create_desktop_pet", "browser_use", "extensions", "bundle-mcp"];
 export type GatewayBuiltinToolId = (typeof GATEWAY_BUILTIN_TOOL_IDS)[number];

package/dist/src/gateway/agent-builtin-tools.js

@@ -25,6 +25,8 @@ const GATEWAY_BUILTIN_TOOL_IDS = [
 	"skills_list",
 	"skill_view",
 	"skill_manage",
+	"skills_marketplace_search",
+	"skill_install",
 	"web_search",
 	"web_fetch",
 	"web_extract",

package/dist/src/gateway/agents-admin.js

@@ -1,5 +1,5 @@
-import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentManifest } from "../agent-manifest/resolver.js";
+import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveAgentDir, resolveAgentProfileDir, resolveAgentWorkspaceDir, resolveDefaultAgentId, resolveUserPath, validateAgentIdForNewAgent } from "../agent/agent-scope.js";
 import { resolveEffectiveAgentProfile } from "../config/agent-profile.js";
 import { WORKSPACE_FILES, init_paths, resolveUserProfilePath } from "../config/paths.js";
 import { AGENT_PROFILE_MARKDOWN_SYSTEM_FILES, REQUIRED_AGENT_PROFILE_MARKDOWN_FILE_SET } from "../agent/context/workspace.js";

package/dist/src/gateway/heartbeat/service.js

@@ -1,9 +1,9 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { shouldSilence, stripHeartbeatToken } from "../../heartbeat/tokens.js";
-import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { isWithinActiveHours } from "../../heartbeat/active-hours.js";
 import { isHeartbeatContentEmpty } from "../../heartbeat/content-check.js";
+import { appendCronEventLines } from "../../heartbeat/event-prompt.js";
 import { createHeartbeatWake } from "../../heartbeat/wake.js";
 import { resolveHeartbeatMdPath } from "../workspace-heartbeat-path.js";
 import { readFile } from "fs/promises";

package/dist/src/gateway/hono/routes/commands-skills.js

@@ -1,11 +1,11 @@
 import { effectiveWorkspacePathForSession } from "../../../session/session-workspace.js";
 import { getProjectForSession } from "../../../projects/workspace.js";
+import { isRegisteredProvider } from "../../../agent/skills/marketplace/registry.js";
+import "../../../agent/skills/skills-marketplace.js";
 import { isSkillInstallTarget } from "../../../agent/skills/install-target.js";
 import { commandRegistry } from "../../../chat-commands/registry.js";
-import { isRegisteredProvider } from "../../../agent/skills/marketplace/registry.js";
 import { buildReviewContext, resolveGitRoot } from "../../../review/review-git.js";
 import "../../../chat-commands/index.js";
-import "../../../agent/skills/skills-marketplace.js";
 //#region src/gateway/hono/routes/commands-skills.ts
 function parseMarketplaceProviderQuery(raw) {
 	const v = raw?.trim().toLowerCase();