@clinebot/core 0.0.35 → 0.0.37

package/src/extensions/config/agent-config-loader.ts

@@ -43,12 +43,14 @@ export function resolveAgentsConfigDirPath(): string {
 	return resolveAgentsConfigDirPathFromShared();
 }
 
-export function resolveAgentConfigSearchPaths(): string[] {
-	// Documents path first, then settings path so settings location takes precedence.
-	return resolveAgentConfigSearchPathsFromShared();
+export function resolveAgentConfigSearchPaths(
+	workspacePath?: string,
+): string[] {
+	return resolveAgentConfigSearchPathsFromShared(workspacePath);
 }
 
 export interface CreateAgentConfigWatcherOptions {
+	workspacePath?: string;
 	directoryPathOrPaths?: string | ReadonlyArray<string>;
 	debounceMs?: number;
 	emitParseErrors?: boolean;
@@ -56,6 +58,7 @@ export interface CreateAgentConfigWatcherOptions {
 
 function toDirectoryPaths(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): string[] {
 	if (Array.isArray(directoryPathOrPaths)) {
 		return [...directoryPathOrPaths];
@@ -63,15 +66,16 @@ function toDirectoryPaths(
 	if (typeof directoryPathOrPaths === "string") {
 		return [directoryPathOrPaths];
 	}
-	return resolveAgentConfigSearchPaths();
+	return resolveAgentConfigSearchPaths(workspacePath);
 }
 
 export function createAgentConfigDefinition(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): UnifiedConfigDefinition<"agent", AgentYamlConfig> {
 	return {
 		type: "agent",
-		directories: toDirectoryPaths(directoryPathOrPaths),
+		directories: toDirectoryPaths(directoryPathOrPaths, workspacePath),
 		includeFile: (fileName) => isAgentConfigYamlFile(fileName),
 		parseFile: (context) => parseAgentConfigFromYaml(context.content),
 		resolveId: (config) => normalizeAgentConfigName(config.name),
@@ -82,7 +86,12 @@ export function createAgentConfigWatcher(
 	options?: CreateAgentConfigWatcherOptions,
 ): AgentConfigWatcher {
 	return new UnifiedConfigFileWatcher(
-		[createAgentConfigDefinition(options?.directoryPathOrPaths)],
+		[
+			createAgentConfigDefinition(
+				options?.directoryPathOrPaths,
+				options?.workspacePath,
+			),
+		],
 		{
 			debounceMs: options?.debounceMs,
 			emitParseErrors: options?.emitParseErrors,
@@ -92,9 +101,10 @@ export function createAgentConfigWatcher(
 
 export async function readAgentConfigsFromDisk(
 	directoryPathOrPaths?: string | ReadonlyArray<string>,
+	workspacePath?: string,
 ): Promise<Map<string, AgentYamlConfig>> {
 	const watcher = new UnifiedConfigFileWatcher([
-		createAgentConfigDefinition(directoryPathOrPaths),
+		createAgentConfigDefinition(directoryPathOrPaths, workspacePath),
 	]);
 	await watcher.refreshAll();
 	const snapshot = watcher.getSnapshot("agent");

package/src/extensions/config/runtime-commands.ts

@@ -1,3 +1,4 @@
+import { truncateSplit } from "@clinebot/shared";
 import type {
 	SkillConfig,
 	UserInstructionConfigWatcher,
@@ -10,6 +11,7 @@ export type AvailableRuntimeCommand = {
 	id: string;
 	name: string;
 	instructions: string;
+	description?: string;
 	kind: RuntimeCommandKind;
 };
 
@@ -32,6 +34,10 @@ function listCommandsForKind(
 			id,
 			name: record.item.name,
 			instructions: record.item.instructions,
+			description: truncateSplit(
+				record.item.description ?? record.item.instructions,
+				".",
+			),
 			kind,
 		}))
 		.sort((a, b) => a.name.localeCompare(b.name));

package/src/extensions/config/user-instruction-config-loader.ts

@@ -52,6 +52,7 @@ export interface RuleConfig {
 export interface WorkflowConfig {
 	name: string;
 	disabled?: boolean;
+	description?: string;
 	instructions: string;
 	frontmatter: Record<string, unknown>;
 }

package/src/extensions/context/agentic-compaction.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import { createHandler } from "@clinebot/llms";
 import type { BasicLogger } from "@clinebot/shared";
 import type {
@@ -6,6 +5,7 @@ import type {
 	CoreCompactionResult,
 	CoreCompactionSummarizerConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 import {
 	buildSummaryMessage,
 	buildSummaryRequest,
@@ -20,7 +20,7 @@ import {
 } from "./compaction-shared";
 
 async function generateSummary(options: {
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	request: string;
 	logger?: BasicLogger;
 }): Promise<string> {
@@ -48,7 +48,7 @@ async function generateSummary(options: {
 
 export async function runAgenticCompaction(options: {
 	context: CoreCompactionContext;
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	summarizer?: CoreCompactionSummarizerConfig;
 	preserveRecentTokens: number;
 	estimateMessageTokens: EstimateMessageTokens;

package/src/extensions/context/basic-compaction.ts

@@ -33,9 +33,9 @@ function sanitizeMessageForBasic(
 		return text ? { ...message, content: text } : undefined;
 	}
 
-	// Preserve array structure: keep only text blocks with non-empty content.
+	// Preserve multimodal structure: trim text blocks, keep non-text blocks intact.
 	const kept = message.content.filter(
-		(block) => block.type === "text" && block.text.trim(),
+		(block) => block.type !== "text" || block.text.trim(),
 	);
 	if (kept.length === 0) {
 		return undefined;

package/src/extensions/context/compaction-shared.ts

@@ -1,9 +1,10 @@
-import type * as LlmsProviders from "@clinebot/llms";
+import type { ToolResultContent } from "@clinebot/llms";
 import type { MessageWithMetadata } from "@clinebot/shared";
 import type {
 	CoreCompactionContext,
 	CoreCompactionSummarizerConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 
 export const DEFAULT_CONTEXT_WINDOW_TOKENS = 200_000;
 export const DEFAULT_THRESHOLD_RATIO = 0.95;
@@ -41,7 +42,7 @@ export function truncateText(text: string, limit: number): string {
 }
 
 export function flattenToolResultContent(
-	content: LlmsProviders.ToolResultContent["content"],
+	content: ToolResultContent["content"],
 ): string {
 	if (typeof content === "string") {
 		return truncateText(content, TOOL_RESULT_CHAR_LIMIT);
@@ -404,9 +405,9 @@ Edited: ${options.fileOps.modifiedFiles.join(", ") || "none"}`,
 }
 
 export function resolveSummarizerConfig(options: {
-	activeProviderConfig: LlmsProviders.ProviderConfig;
+	activeProviderConfig: ProviderConfig;
 	summarizer?: CoreCompactionSummarizerConfig;
-}): LlmsProviders.ProviderConfig {
+}): ProviderConfig {
 	const summarizer = options.summarizer;
 	if (!summarizer) {
 		return {

package/src/extensions/context/compaction.ts

@@ -1,4 +1,3 @@
-import type * as LlmsProviders from "@clinebot/llms";
 import type {
 	CoreCompactionConfig,
 	CoreCompactionContext,
@@ -6,6 +5,7 @@ import type {
 	CoreCompactionStrategy,
 	CoreSessionConfig,
 } from "../../types/config";
+import type { ProviderConfig } from "../../types/provider-settings";
 import { runAgenticCompaction } from "./agentic-compaction";
 import { runBasicCompaction } from "./basic-compaction";
 import {
@@ -41,7 +41,7 @@ type EstimateMessageTokens = ReturnType<typeof createTokenEstimator>;
 
 type BuiltinCompactionStrategyOptions = {
 	context: CoreCompactionContext;
-	providerConfig: LlmsProviders.ProviderConfig;
+	providerConfig: ProviderConfig;
 	compaction: CoreCompactionConfig | undefined;
 	estimateMessageTokens: EstimateMessageTokens;
 	logger: Pick<CoreSessionConfig, "logger">["logger"];
@@ -129,7 +129,7 @@ export function createContextCompactionPrepareTurn(
 		({
 			providerId: config.providerId,
 			modelId: config.modelId,
-		} as LlmsProviders.ProviderConfig);
+		} as ProviderConfig);
 	const estimateMessageTokens = createTokenEstimator();
 	const strategy = userCompaction?.strategy ?? "basic";
 	const runBuiltinStrategy = BUILTIN_COMPACTION_STRATEGIES[strategy];

package/src/extensions/plugin/plugin-config-loader.ts

@@ -1,5 +1,9 @@
 import { existsSync } from "node:fs";
-import type { AgentConfig } from "@clinebot/shared";
+import type {
+	AgentConfig,
+	PluginSetupContext,
+	WorkspaceInfo,
+} from "@clinebot/shared";
 import {
 	discoverPluginModulePaths as discoverPluginModulePathsFromShared,
 	resolveConfiguredPluginModulePaths,
@@ -8,6 +12,7 @@ import {
 import type { PluginLoadDiagnostics } from "./plugin-load-report";
 import { loadAgentPluginsFromPathsWithDiagnostics } from "./plugin-loader";
 import { loadSandboxedPlugins } from "./plugin-sandbox";
+import type { PluginTargeting } from "./plugin-targeting";
 
 type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
 
@@ -54,13 +59,26 @@ export function resolveAgentPluginPaths(
 }
 
 export interface ResolveAndLoadAgentPluginsOptions
-	extends ResolveAgentPluginPathsOptions {
+	extends ResolveAgentPluginPathsOptions,
+		PluginTargeting {
 	mode?: "sandbox" | "in_process";
 	exportName?: string;
 	importTimeoutMs?: number;
 	hookTimeoutMs?: number;
 	contributionTimeoutMs?: number;
 	onEvent?: (event: { name: string; payload?: unknown }) => void;
+	/**
+	 * Structured workspace and git metadata. Forwarded to sandboxed plugins
+	 * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
+	 * in the extension context.
+	 */
+	workspaceInfo?: WorkspaceInfo;
+	session?: PluginSetupContext["session"];
+	client?: PluginSetupContext["client"];
+	user?: PluginSetupContext["user"];
+	automation?: PluginSetupContext["automation"];
+	logger?: PluginSetupContext["logger"];
+	telemetry?: PluginSetupContext["telemetry"];
 }
 
 export async function resolveAndLoadAgentPlugins(
@@ -80,6 +98,15 @@ export async function resolveAndLoadAgentPlugins(
 		const report = await loadAgentPluginsFromPathsWithDiagnostics(paths, {
 			cwd: options.cwd,
 			exportName: options.exportName,
+			providerId: options.providerId,
+			modelId: options.modelId,
+			session: options.session,
+			client: options.client,
+			user: options.user,
+			workspaceInfo: options.workspaceInfo,
+			automation: options.automation,
+			logger: options.logger,
+			telemetry: options.telemetry,
 		});
 		return {
 			extensions: report.plugins,
@@ -95,6 +122,14 @@ export async function resolveAndLoadAgentPlugins(
 		hookTimeoutMs: options.hookTimeoutMs,
 		contributionTimeoutMs: options.contributionTimeoutMs,
 		onEvent: options.onEvent,
+		providerId: options.providerId,
+		modelId: options.modelId,
+		cwd: options.cwd,
+		session: options.session,
+		client: options.client,
+		user: options.user,
+		workspaceInfo: options.workspaceInfo,
+		logger: options.logger,
 	});
 	return {
 		extensions: sandboxed.extensions ?? [],

package/src/extensions/plugin/plugin-loader.ts

@@ -1,17 +1,23 @@
 import { resolve } from "node:path";
-import type { AgentConfig } from "@clinebot/shared";
+import type { AgentExtension, PluginSetupContext } from "@clinebot/shared";
+import { normalizePluginManifest } from "@clinebot/shared";
 import type {
 	PluginInitializationFailure,
 	PluginInitializationWarning,
 } from "./plugin-load-report";
 import { importPluginModule } from "./plugin-module-import";
+import {
+	matchesPluginManifestTargeting,
+	type PluginTargeting,
+} from "./plugin-targeting";
 
-type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
 type PluginLike = {
 	name: string;
 	manifest: {
 		capabilities: string[];
 		hookStages?: string[];
+		providerIds?: string[];
+		modelIds?: string[];
 	};
 };
 
@@ -19,6 +25,13 @@ export interface LoadAgentPluginFromPathOptions {
 	exportName?: string;
 	cwd?: string;
 	useCache?: boolean;
+	session?: PluginSetupContext["session"];
+	client?: PluginSetupContext["client"];
+	user?: PluginSetupContext["user"];
+	workspaceInfo?: PluginSetupContext["workspaceInfo"];
+	automation?: PluginSetupContext["automation"];
+	logger?: PluginSetupContext["logger"];
+	telemetry?: PluginSetupContext["telemetry"];
 }
 
 function isObject(value: unknown): value is Record<string, unknown> {
@@ -58,6 +71,22 @@ function validatePluginManifest(
 			`Invalid plugin module at ${absolutePath}: manifest.hookStages must be a string array when provided`,
 		);
 	}
+	if (
+		Object.hasOwn(plugin.manifest, "providerIds") &&
+		!hasValidStringArray(plugin.manifest.providerIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.providerIds must be a string array when provided`,
+		);
+	}
+	if (
+		Object.hasOwn(plugin.manifest, "modelIds") &&
+		!hasValidStringArray(plugin.manifest.modelIds)
+	) {
+		throw new Error(
+			`Invalid plugin module at ${absolutePath}: manifest.modelIds must be a string array when provided`,
+		);
+	}
 }
 
 function validatePluginExport(
@@ -85,7 +114,7 @@ function validatePluginExport(
 export async function loadAgentPluginFromPath(
 	pluginPath: string,
 	options: LoadAgentPluginFromPathOptions = {},
-): Promise<AgentPlugin> {
+): Promise<AgentExtension> {
 	const absolutePath = resolve(options.cwd ?? process.cwd(), pluginPath);
 	const moduleExports = await importPluginModule(absolutePath, {
 		useCache: options.useCache,
@@ -95,13 +124,41 @@ export async function loadAgentPluginFromPath(
 		moduleExports[exportName]) as unknown;
 
 	validatePluginExport(plugin, absolutePath);
-	return plugin as AgentPlugin;
+	const pluginTyped = plugin as AgentExtension;
+	const originalSetup = pluginTyped.setup;
+
+	// Wrap setup to inject workspace context
+	const setupWithContext: AgentExtension["setup"] = originalSetup
+		? (api, _ctx) => {
+				const session = {
+					...options.session,
+					..._ctx.session,
+				};
+				const ctx = {
+					..._ctx,
+					session: Object.keys(session).length > 0 ? session : undefined,
+					client: options.client ?? _ctx.client,
+					user: options.user ?? _ctx.user,
+					workspaceInfo: options.workspaceInfo ?? _ctx.workspaceInfo,
+					automation: options.automation ?? _ctx.automation,
+					logger: options.logger ?? _ctx.logger,
+					telemetry: options.telemetry ?? _ctx.telemetry,
+				};
+				return originalSetup(api, ctx);
+			}
+		: undefined;
+
+	return {
+		...pluginTyped,
+		manifest: normalizePluginManifest(pluginTyped.manifest),
+		setup: setupWithContext,
+	};
 }
 
 export async function loadAgentPluginsFromPaths(
 	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions = {},
-): Promise<AgentPlugin[]> {
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
+): Promise<AgentExtension[]> {
 	const report = await loadAgentPluginsFromPathsWithDiagnostics(
 		pluginPaths,
 		options,
@@ -111,9 +168,9 @@ export async function loadAgentPluginsFromPaths(
 
 export async function loadAgentPluginsFromPathsWithDiagnostics(
 	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions = {},
+	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
 ): Promise<{
-	plugins: AgentPlugin[];
+	plugins: AgentExtension[];
 	failures: PluginInitializationFailure[];
 	warnings: PluginInitializationWarning[];
 }> {
@@ -121,13 +178,16 @@ export async function loadAgentPluginsFromPathsWithDiagnostics(
 	const warnings: PluginInitializationWarning[] = [];
 	const loadedByName = new Map<
 		string,
-		{ plugin: AgentPlugin; pluginPath: string; order: number }
+		{ plugin: AgentExtension; pluginPath: string; order: number }
 	>();
 	let order = 0;
 
 	for (const pluginPath of pluginPaths) {
 		try {
 			const plugin = await loadAgentPluginFromPath(pluginPath, options);
+			if (!matchesPluginManifestTargeting(plugin.manifest, options)) {
+				continue;
+			}
 			const existing = loadedByName.get(plugin.name);
 			if (existing) {
 				warnings.push({

package/src/extensions/plugin/plugin-module-import.ts

@@ -26,8 +26,6 @@ function collectWorkspaceAliases(root: string): Record<string, string> {
 		"@clinebot/agents": resolve(root, "packages/agents/src/index.ts"),
 		"@clinebot/core": resolve(root, "packages/core/src/index.ts"),
 		"@clinebot/llms": resolve(root, "packages/llms/src/index.ts"),
-		"@clinebot/rpc": resolve(root, "packages/rpc/src/index.ts"),
-		"@clinebot/scheduler": resolve(root, "packages/scheduler/src/index.ts"),
 		"@clinebot/shared": resolve(root, "packages/shared/src/index.ts"),
 		"@clinebot/shared/storage": resolve(
 			root,