@xopcai/xopc 0.0.178 → 0.0.180

package/dist/src/agent/lifecycle/timeout-wrapper.js

@@ -40,6 +40,31 @@ async function executeWithTimeout(operation, config) {
 	let timeoutId = null;
 	let isSettled = false;
 	return new Promise((resolve, reject) => {
+		const cleanup = () => {
+			if (timeoutId) {
+				clearTimeout(timeoutId);
+				timeoutId = null;
+			}
+			config.signal?.removeEventListener("abort", onAbort);
+		};
+		const onAbort = () => {
+			if (isSettled) return;
+			isSettled = true;
+			cleanup();
+			const reason = config.signal?.reason;
+			if (reason instanceof Error) {
+				reject(reason);
+				return;
+			}
+			const error = /* @__PURE__ */ new Error("Tool execution was aborted");
+			error.name = "AbortError";
+			reject(error);
+		};
+		if (config.signal?.aborted) {
+			onAbort();
+			return;
+		}
+		config.signal?.addEventListener("abort", onAbort, { once: true });
 		timeoutId = setTimeout(() => {
 			if (isSettled) return;
 			isSettled = true;
@@ -51,15 +76,23 @@ async function executeWithTimeout(operation, config) {
 				executionTimeMs: executionTime,
 				description: config.description
 			}, `Tool "${config.toolName}" timed out after ${timeoutMs}ms (elapsed ${executionTime}ms)${desc}`);
-			reject(new TimeoutError(config.toolName, timeoutMs, config.description, executionTime));
+			const error = new TimeoutError(config.toolName, timeoutMs, config.description, executionTime);
+			try {
+				config.onTimeout?.(error);
+			} catch (callbackError) {
+				log.warn({
+					err: callbackError,
+					toolName: config.toolName
+				}, "Tool timeout cancellation callback failed");
+			} finally {
+				cleanup();
+				reject(error);
+			}
 		}, timeoutMs);
 		operation().then((result) => {
 			if (isSettled) return;
 			isSettled = true;
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-				timeoutId = null;
-			}
+			cleanup();
 			const executionTime = Date.now() - startTime;
 			log.debug({
 				toolName: config.toolName,
@@ -69,10 +102,7 @@ async function executeWithTimeout(operation, config) {
 		}).catch((error) => {
 			if (isSettled) return;
 			isSettled = true;
-			if (timeoutId) {
-				clearTimeout(timeoutId);
-				timeoutId = null;
-			}
+			cleanup();
 			reject(error);
 		});
 	});

package/dist/src/agent/mcp/bundle-mcp-materialize.js

@@ -138,9 +138,9 @@ async function materializeBundleMcpToolsForRun(params) {
 			label: tool.title ?? tool.toolName,
 			description: tool.description || tool.title || tool.fallbackDescription,
 			parameters: tool.inputSchema,
-			execute: async (_toolCallId, input) => {
+			execute: async (_toolCallId, input, signal) => {
 				params.runtime.markUsed();
-				const result = await params.runtime.callTool(tool.serverName, tool.toolName, input);
+				const result = await params.runtime.callTool(tool.serverName, tool.toolName, input, signal);
 				return toAgentToolResult({
 					serverName: tool.serverName,
 					toolName: tool.toolName,

package/dist/src/agent/mcp/bundle-mcp-runtime.js

@@ -192,6 +192,7 @@ function createSessionMcpRuntime(params) {
 						client,
 						transport: resolved.transport,
 						transportType: resolved.transportType,
+						requestTimeoutMs: resolved.requestTimeoutMs,
 						detachStderr: resolved.detachStderr
 					};
 					sessions.set(serverName, session);
@@ -312,7 +313,7 @@ function createSessionMcpRuntime(params) {
 		markUsed() {
 			lastUsedAt = Date.now();
 		},
-		async callTool(serverName, toolName, input) {
+		async callTool(serverName, toolName, input, signal) {
 			failIfDisposed();
 			await getCatalog();
 			const session = sessions.get(serverName);
@@ -320,6 +321,10 @@ function createSessionMcpRuntime(params) {
 			return await session.client.callTool({
 				name: toolName,
 				arguments: isMcpConfigRecord(input) ? input : {}
+			}, void 0, {
+				signal,
+				timeout: session.requestTimeoutMs,
+				maxTotalTimeout: session.requestTimeoutMs
 			});
 		},
 		async dispose() {

package/dist/src/agent/mcp/bundle-mcp-types.d.ts

@@ -56,7 +56,7 @@ export type SessionMcpRuntime = {
     acquireLease?: () => () => void;
     getCatalog: () => Promise<McpToolCatalog>;
     markUsed: () => void;
-    callTool: (serverName: string, toolName: string, input: unknown) => Promise<CallToolResult>;
+    callTool: (serverName: string, toolName: string, input: unknown, signal?: AbortSignal) => Promise<CallToolResult>;
     dispose: () => Promise<void>;
 };
 export type SessionMcpRuntimeManager = {

package/dist/src/agent/mcp/mcp-stdio-transport.js

@@ -1,7 +1,7 @@
 import { killProcessTree } from "../../process/kill-tree.js";
 import { spawn } from "node:child_process";
-import process from "node:process";
 import { PassThrough } from "node:stream";
+import process from "node:process";
 import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { ReadBuffer, serializeMessage } from "@modelcontextprotocol/sdk/shared/stdio.js";
 //#region src/agent/mcp/mcp-stdio-transport.ts

package/dist/src/agent/mcp/mcp-transport-config.d.ts

@@ -2,6 +2,7 @@ import { type HttpMcpTransportType } from "./mcp-http.js";
 type ResolvedBaseMcpTransportConfig = {
     description: string;
     connectionTimeoutMs: number;
+    requestTimeoutMs: number;
 };
 export type ResolvedStdioMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
     kind: "stdio";
@@ -18,5 +19,6 @@ export type ResolvedHttpMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
     headers?: Record<string, string>;
 };
 export type ResolvedMcpTransportConfig = ResolvedStdioMcpTransportConfig | ResolvedHttpMcpTransportConfig;
+export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 60000;
 export declare function resolveMcpTransportConfig(serverName: string, rawServer: unknown): ResolvedMcpTransportConfig | null;
 export {};

package/dist/src/agent/mcp/mcp-transport-config.js

@@ -10,10 +10,15 @@ init_logger();
 init_string_coerce();
 const log = createLogger("Mcp:Bundle");
 const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
+const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 6e4;
 function getConnectionTimeoutMs(rawServer) {
 	if (rawServer && typeof rawServer === "object" && typeof rawServer.connectionTimeoutMs === "number" && rawServer.connectionTimeoutMs > 0) return rawServer.connectionTimeoutMs;
 	return DEFAULT_CONNECTION_TIMEOUT_MS;
 }
+function getRequestTimeoutMs(rawServer) {
+	if (rawServer && typeof rawServer === "object" && typeof rawServer.requestTimeoutMs === "number" && rawServer.requestTimeoutMs > 0) return rawServer.requestTimeoutMs;
+	return DEFAULT_MCP_REQUEST_TIMEOUT_MS;
+}
 function getRequestedTransport(rawServer) {
 	if (!rawServer || typeof rawServer !== "object" || typeof rawServer.transport !== "string") return "";
 	return normalizeLowercaseStringOrEmpty(rawServer.transport);
@@ -46,7 +51,8 @@ function resolveHttpTransportConfig(serverName, rawServer, transportType) {
 		url: launch.config.url,
 		headers: launch.config.headers,
 		description: describeHttpMcpServerLaunchConfig(launch.config),
-		connectionTimeoutMs: getConnectionTimeoutMs(rawServer)
+		connectionTimeoutMs: getConnectionTimeoutMs(rawServer),
+		requestTimeoutMs: getRequestTimeoutMs(rawServer)
 	};
 }
 function resolveMcpTransportConfig(serverName, rawServer) {
@@ -65,7 +71,8 @@ function resolveMcpTransportConfig(serverName, rawServer) {
 		env: stdioLaunch.config.env,
 		cwd: stdioLaunch.config.cwd,
 		description: describeStdioMcpServerLaunchConfig(stdioLaunch.config),
-		connectionTimeoutMs: getConnectionTimeoutMs(rawServer)
+		connectionTimeoutMs: getConnectionTimeoutMs(rawServer),
+		requestTimeoutMs: getRequestTimeoutMs(rawServer)
 	};
 	if (effectiveTransport && effectiveTransport !== "sse" && effectiveTransport !== "streamable-http") {
 		log.warn(`bundle-mcp: skipped server "${logServerName}" because transport "${sanitizeForLog(effectiveTransport)}" is not supported.`);
@@ -80,4 +87,4 @@ function resolveMcpTransportConfig(serverName, rawServer) {
 	return null;
 }
 //#endregion
-export { resolveMcpTransportConfig };
+export { DEFAULT_MCP_REQUEST_TIMEOUT_MS, resolveMcpTransportConfig };

package/dist/src/agent/mcp/mcp-transport.d.ts

@@ -4,6 +4,7 @@ export type ResolvedMcpTransport = {
     description: string;
     transportType: "stdio" | "sse" | "streamable-http";
     connectionTimeoutMs: number;
+    requestTimeoutMs: number;
     detachStderr?: () => void;
 };
 export declare function resolveMcpTransport(serverName: string, rawServer: unknown): ResolvedMcpTransport | null;

package/dist/src/agent/mcp/mcp-transport.js

@@ -60,6 +60,7 @@ function resolveMcpTransport(serverName, rawServer) {
 			description: resolved.description,
 			transportType: "stdio",
 			connectionTimeoutMs: resolved.connectionTimeoutMs,
+			requestTimeoutMs: resolved.requestTimeoutMs,
 			detachStderr: attachStderrLogging(serverName, transport)
 		};
 	}
@@ -70,7 +71,8 @@ function resolveMcpTransport(serverName, rawServer) {
 		}),
 		description: resolved.description,
 		transportType: "streamable-http",
-		connectionTimeoutMs: resolved.connectionTimeoutMs
+		connectionTimeoutMs: resolved.connectionTimeoutMs,
+		requestTimeoutMs: resolved.requestTimeoutMs
 	};
 	const headers = { ...resolved.headers };
 	const hasHeaders = Object.keys(headers).length > 0;
@@ -82,7 +84,8 @@ function resolveMcpTransport(serverName, rawServer) {
 		}),
 		description: resolved.description,
 		transportType: "sse",
-		connectionTimeoutMs: resolved.connectionTimeoutMs
+		connectionTimeoutMs: resolved.connectionTimeoutMs,
+		requestTimeoutMs: resolved.requestTimeoutMs
 	};
 }
 //#endregion

package/dist/src/agent/memory/dreaming/config.js

@@ -1,5 +1,5 @@
-import { DEFAULT_DEEP_CRON, DEFAULT_LIGHT_CRON, DEFAULT_REM_CRON } from "./constants.js";
 import { buildMemoryRuntime } from "../../../agent-runtime/memory-runtime.js";
+import { DEFAULT_DEEP_CRON, DEFAULT_LIGHT_CRON, DEFAULT_REM_CRON } from "./constants.js";
 //#region src/agent/memory/dreaming/config.ts
 function clampScore(value, fallback) {
 	if (!Number.isFinite(value)) return fallback;

package/dist/src/agent/memory/user-context-coordinator.d.ts

@@ -14,6 +14,7 @@ export declare class UserContextCoordinator {
     private readonly userTurn;
     private readonly correctionTargets;
     private readonly planner;
+    private readonly contextCompiler;
     constructor(options: UserContextCoordinatorOptions);
     forgetSession(sessionKey: string): void;
     clear(): void;

package/dist/src/agent/memory/user-context-coordinator.js

@@ -2,6 +2,7 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { setLatestMemoryInjectFeedback } from "../../storage/sqlite/memory-records-repository.js";
 import "../../storage/sqlite/index.js";
+import { ContextCompiler } from "../../user-context/context-compiler.js";
 import { shouldPlanUserContextThisTurn } from "./memory-config.js";
 import { UserContextPlanner } from "./context/planner.js";
 import { isExplicitUnderstandingCorrection } from "./understanding/correction.js";
@@ -13,6 +14,7 @@ var UserContextCoordinator = class {
 	userTurn = /* @__PURE__ */ new Map();
 	correctionTargets = /* @__PURE__ */ new Map();
 	planner = new UserContextPlanner();
+	contextCompiler = new ContextCompiler();
 	constructor(options) {
 		this.options = options;
 	}
@@ -61,7 +63,7 @@ var UserContextCoordinator = class {
 		const turn = (this.userTurn.get(sessionKey) ?? 0) + 1;
 		this.userTurn.set(sessionKey, turn);
 		if (!shouldPlanUserContextThisTurn(config, turn)) return empty();
-		return this.planner.plan({
+		const plan = await this.planner.plan({
 			memoryManager: this.options.getMemoryManagerForSession(sessionKey),
 			agentId: this.options.getAgentIdForSession(sessionKey),
 			sessionKey,
@@ -69,6 +71,20 @@ var UserContextCoordinator = class {
 			userMessage,
 			excludedRecordIds
 		});
+		if (plan.traceId) try {
+			this.contextCompiler.capture({
+				sessionKey,
+				query,
+				plan
+			});
+		} catch (err) {
+			log.debug({
+				err,
+				sessionKey,
+				traceId: plan.traceId
+			}, "Context snapshot was not persisted");
+		}
+		return plan;
 	}
 	async afterTurn(sessionKey, userPlainText) {
 		if (!this.options.isEnabledForSession(sessionKey)) return void 0;

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.d.ts

@@ -10,6 +10,6 @@ export declare const MIN_AGENT_TURN_TIMEOUT_MS = 60000;
 export declare const MAX_AGENT_TURN_TIMEOUT_MS: number;
 /** Default per-turn timeout (30 minutes). */
 export declare const DEFAULT_AGENT_TURN_TIMEOUT_MS: number;
-export declare function resolveAgentTurnTimeoutMs(_config?: Config): number;
+export declare function resolveAgentTurnTimeoutMs(config?: Config, sessionKey?: string): number;
 export declare function isAgentTurnTimeoutError(err: unknown): boolean;
 export declare function runAgentTurnWithTimeout(agent: Agent, runTurn: () => Promise<void>, timeoutMs: number): Promise<void>;

package/dist/src/agent/orchestration/run-agent-turn-with-timeout.js

@@ -1,3 +1,4 @@
+import { resolveEffectiveAgentManifestForSession } from "../../config/agent-profile.js";
 //#region src/agent/orchestration/run-agent-turn-with-timeout.ts
 /** Minimum per-turn timeout (1 minute). */
 const MIN_AGENT_TURN_TIMEOUT_MS = 6e4;
@@ -5,8 +6,11 @@ const MIN_AGENT_TURN_TIMEOUT_MS = 6e4;
 const MAX_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
 /** Default per-turn timeout (30 minutes). */
 const DEFAULT_AGENT_TURN_TIMEOUT_MS = 1800 * 1e3;
-function resolveAgentTurnTimeoutMs(_config) {
-	return DEFAULT_AGENT_TURN_TIMEOUT_MS;
+function resolveAgentTurnTimeoutMs(config, sessionKey) {
+	if (!config) return DEFAULT_AGENT_TURN_TIMEOUT_MS;
+	const configured = resolveEffectiveAgentManifestForSession(config, sessionKey).runtime?.timeoutMs;
+	if (!configured) return DEFAULT_AGENT_TURN_TIMEOUT_MS;
+	return Math.min(MAX_AGENT_TURN_TIMEOUT_MS, Math.max(MIN_AGENT_TURN_TIMEOUT_MS, configured));
 }
 function isAgentTurnTimeoutError(err) {
 	return err instanceof Error && err.message.startsWith("Agent turn timed out after");

package/dist/src/agent/outcomes/{task-evaluation.d.ts → execution-evaluation.d.ts}

@@ -1,5 +1,5 @@
-import type { TaskOutcome } from '../../storage/sqlite/task-outcome-repository.js';
-export interface TaskEvaluationReplay {
+import type { ExecutionReceipt } from '../../storage/sqlite/execution-receipt-repository.js';
+export interface ExecutionEvaluationReplay {
     total: number;
     falseCompletions: number;
     verificationDrift: number;
@@ -17,4 +17,4 @@ export interface TaskEvaluationReplay {
         replayedVerification: string;
     }>;
 }
-export declare function replayTaskEvaluation(outcomes: TaskOutcome[]): TaskEvaluationReplay;
+export declare function replayExecutionEvaluation(outcomes: ExecutionReceipt[]): ExecutionEvaluationReplay;

package/dist/src/agent/outcomes/{task-evaluation.js → execution-evaluation.js}

@@ -1,13 +1,13 @@
-import { verifyTaskCompletion } from "./task-verifier.js";
-//#region src/agent/outcomes/task-evaluation.ts
-function replayTaskEvaluation(outcomes) {
+import { verifyExecutionCompletion } from "./execution-verifier.js";
+//#region src/agent/outcomes/execution-evaluation.ts
+function replayExecutionEvaluation(outcomes) {
 	const completed = outcomes.filter((outcome) => outcome.status !== "running");
 	const byChannel = {};
 	const cases = [];
 	let falseCompletions = 0;
 	let supportMismatches = 0;
 	for (const outcome of completed) {
-		const replayed = verifyTaskCompletion({
+		const replayed = verifyExecutionCompletion({
 			status: outcome.status,
 			acceptanceCriteria: outcome.contract?.acceptanceCriteria ?? [],
 			evidence: outcome.evidence
@@ -45,4 +45,4 @@ function replayTaskEvaluation(outcomes) {
 	};
 }
 //#endregion
-export { replayTaskEvaluation };
+export { replayExecutionEvaluation };

package/dist/src/agent/outcomes/execution-verifier.d.ts

@@ -0,0 +1,29 @@
+export type ExecutionVerificationStatus = 'passed' | 'failed' | 'unverified';
+export type ExecutionFailurePhase = 'planning' | 'execution' | 'verification' | 'approval' | 'runtime';
+export type ExecutionFailureCode = 'cancelled' | 'timeout' | 'tool_failed' | 'verification_failed' | 'approval_required' | 'conflict' | 'model_failed' | 'unknown';
+export type ExecutionRecoveryAction = 'replan' | 'retry_with_changed_strategy' | 'request_user_input' | 'none';
+export interface ExecutionVerification {
+    status: ExecutionVerificationStatus;
+    checks: Array<{
+        criterion: string;
+        status: ExecutionVerificationStatus;
+        evidenceTitles: string[];
+    }>;
+}
+export interface ExecutionFailureDiagnosis {
+    code: ExecutionFailureCode;
+    phase: ExecutionFailurePhase;
+    recoveryAction: ExecutionRecoveryAction;
+}
+export declare function verifyExecutionCompletion(input: {
+    status: 'succeeded' | 'failed' | 'cancelled';
+    acceptanceCriteria: string[];
+    evidence: Array<{
+        title: string;
+        verifies?: string[];
+    }>;
+}): ExecutionVerification;
+export declare function diagnoseExecutionFailure(input: {
+    status: 'failed' | 'cancelled';
+    summary: string;
+}): ExecutionFailureDiagnosis;

package/dist/src/agent/outcomes/{task-verifier.js → execution-verifier.js}

@@ -1,5 +1,5 @@
-//#region src/agent/outcomes/task-verifier.ts
-function verifyTaskCompletion(input) {
+//#region src/agent/outcomes/execution-verifier.ts
+function verifyExecutionCompletion(input) {
 	const checks = input.acceptanceCriteria.map((criterion) => {
 		const evidenceTitles = input.evidence.filter((evidence) => evidence.verifies?.includes(criterion)).map((evidence) => evidence.title);
 		return {
@@ -24,7 +24,7 @@ function verifyTaskCompletion(input) {
 		checks
 	};
 }
-function diagnoseTaskFailure(input) {
+function diagnoseExecutionFailure(input) {
 	const text = input.summary.toLocaleLowerCase();
 	if (input.status === "cancelled") return {
 		code: "cancelled",
@@ -68,4 +68,4 @@ function diagnoseTaskFailure(input) {
 	};
 }
 //#endregion
-export { diagnoseTaskFailure, verifyTaskCompletion };
+export { diagnoseExecutionFailure, verifyExecutionCompletion };

package/dist/src/agent/service/direct-turn-helpers.d.ts

@@ -64,6 +64,7 @@ export interface RunDirectAgentTurnInput {
     runId?: string;
     userMessage: AgentMessage;
     abortSignal?: AbortSignal;
+    deadlineAtMs?: number;
     sourceImages?: ImageContent[];
     onEvent?: (event: EmbeddedStreamEvent) => void;
 }

package/dist/src/agent/service/direct-turn-helpers.js

@@ -99,6 +99,7 @@ async function runDirectAgentTurn(deps, input) {
 		modelManager: deps.modelManager,
 		getConfig: () => deps.config,
 		abortSignal: input.abortSignal,
+		deadlineAtMs: input.deadlineAtMs,
 		beforeTurn: () => deps.agentManager.beginBackgroundReviewUserTurn(input.sessionKey),
 		onEvent: input.onEvent
 	});

package/dist/src/agent/service/process-direct-one-shot.d.ts

@@ -33,4 +33,7 @@ export declare function runProcessDirect(deps: RunProcessDirectDeps, input: {
     sessionKey: string;
     attachments?: InboundAttachmentInput[];
     thinking?: string;
+    signal?: AbortSignal;
+    runId?: string;
+    deadlineAtMs?: number;
 }): Promise<string>;

package/dist/src/agent/service/process-direct-one-shot.js

@@ -61,7 +61,10 @@ async function runProcessDirect(deps, input) {
 					config: deps.config
 				}, {
 					sessionKey: input.sessionKey,
-					userMessage
+					runId: input.runId,
+					userMessage,
+					abortSignal: input.signal,
+					deadlineAtMs: input.deadlineAtMs
 				}));
 			} finally {
 				clearPendingTranscriptUserMessage(input.sessionKey, pendingUserMessage);

package/dist/src/agent/service/process-direct-streaming.js

@@ -4,8 +4,10 @@ import { formatAgentRunErrorForClient } from "../client-error-format.js";
 import { resolveConfiguredActivityDetailDefault, resolveEffectiveReasoningLevel } from "../../session/thinking-resolve.js";
 import { initSessionTurn } from "../../session/init-session-turn.js";
 import "../../session/index.js";
-import { isVoiceLikeAttachment, mergeSttConfigFromAppConfig, mergeVoiceTranscriptsIntoUserText } from "../../channels/attachments/voice-stt-webchat.js";
+import { mergeSttConfigFromAppConfig } from "../../voice/stt/config.js";
+import "../../voice/stt/index.js";
 import { abortEmbeddedRun } from "../embedded/runs.js";
+import { isVoiceLikeAttachment, mergeVoiceTranscriptsIntoUserText } from "../../channels/attachments/voice-stt-webchat.js";
 import { applyReasoningVisibilityToSseEvent } from "../streaming/reasoning-visibility-sse.js";
 import { injectSourceContextIntoUserMessage } from "../source-context/injector.js";
 import { isSessionSourceBinding } from "../source-context/types.js";

package/dist/src/agent/service.d.ts

@@ -113,6 +113,7 @@ export declare class AgentService {
     getCapabilityCatalog(sessionKey?: string): AgentCapabilityCatalogEntry[];
     getSkillMarkdownSource(skillName: string): SkillMarkdownPreviewPayload | null;
     refreshSkillsAfterDiskChange(): void;
+    refreshSkillsAfterTrustChange(): void;
     installSkillFromSource(opts: SkillInstallToolOptions): Promise<SkillInstallToolResult>;
     installSkillFromMarketplace(opts: MarketplaceSkillInstallToolOptions): Promise<MarketplaceSkillInstallToolResult>;
     refreshSkillsAfterSkillConfigChange(): void;

package/dist/src/agent/service.js

@@ -2,10 +2,10 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { parseNoteAttachmentTarget } from "../notes/attachment-ref.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
-import { applyConfigOverrides } from "../config/runtime-overrides.js";
 import { init_agent_scope, resolveAgentHomeDir, resolveDefaultAgentId } from "./agent-scope.js";
-import { extractProfileAgentId } from "../config/agent-profile.js";
 import { init_paths, resolveUserProfilePath } from "../config/paths.js";
+import { applyConfigOverrides } from "../config/runtime-overrides.js";
+import { extractProfileAgentId } from "../config/agent-profile.js";
 import { extractTextContent } from "./context/workspace.js";
 import { effectiveWorkspacePathForSession } from "../session/session-workspace.js";
 import { getProjectForSession } from "../projects/workspace.js";
@@ -532,6 +532,9 @@ var AgentService = class {
 	refreshSkillsAfterDiskChange() {
 		this.agentManager.refreshSkillsAfterDiskChange();
 	}
+	refreshSkillsAfterTrustChange() {
+		this.agentManager.refreshSkillsAfterTrustChange();
+	}
 	async installSkillFromSource(opts) {
 		const target = normalizeSkillInstallTarget(opts.target);
 		const workspace = opts.workspace?.trim() || (opts.sessionKey ? this.agentManager.getResolvedWorkspaceForSession(opts.sessionKey) : void 0) || this.workspaceDir;

package/dist/src/agent/session/session-inspector.js

@@ -1,8 +1,8 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_workspace_defaults, resolveDefaultAgentWorkspaceDir } from "../../config/workspace-defaults.js";
-import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
+import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { effectiveWorkspacePathForSession, projectWorkspacePath } from "../../session/session-workspace.js";
 import { getProjectForSession } from "../../projects/workspace.js";
 import { resolveCompactionPolicy } from "../memory/compaction-policy.js";

package/dist/src/agent/skills/config.js

@@ -162,6 +162,12 @@ function isSkillEnabled(skill, skillsConfig) {
 */
 function validateSkillConfig(config) {
 	const errors = [];
+	const extraDirs = config.load?.extraDirs;
+	if (extraDirs !== void 0 && (!Array.isArray(extraDirs) || !extraDirs.every((dir) => typeof dir === "string"))) errors.push("load.extraDirs must contain only strings");
+	const agentsGlobalSource = config.load?.sources?.agentsGlobal;
+	if (agentsGlobalSource !== void 0 && (typeof agentsGlobalSource !== "object" || agentsGlobalSource === null || Array.isArray(agentsGlobalSource) || "enabled" in agentsGlobalSource && typeof agentsGlobalSource.enabled !== "boolean")) errors.push("load.sources.agentsGlobal.enabled must be a boolean");
+	const agentsWorkspaceSource = config.load?.sources?.agentsWorkspace;
+	if (agentsWorkspaceSource !== void 0 && (typeof agentsWorkspaceSource !== "object" || agentsWorkspaceSource === null || Array.isArray(agentsWorkspaceSource) || "enabled" in agentsWorkspaceSource && typeof agentsWorkspaceSource.enabled !== "boolean")) errors.push("load.sources.agentsWorkspace.enabled must be a boolean");
 	if (config.toolGating !== void 0 && typeof config.toolGating !== "boolean") errors.push("toolGating must be a boolean");
 	if (config.agentWritePolicy !== void 0 && config.agentWritePolicy !== "global" && config.agentWritePolicy !== "workspace" && config.agentWritePolicy !== "both") errors.push("agentWritePolicy must be \"global\", \"workspace\", or \"both\"");
 	const limits = config.limits;

package/dist/src/agent/skills/filesystem-watcher.d.ts

@@ -3,13 +3,17 @@ export interface SkillFilesystemWatcherOptions {
         reason: 'watch';
         changedPath?: string;
     }) => void;
+    /** Dependency-injection override for the ~/.agents/skills compatibility root. */
+    agentsSkillsDir?: string;
 }
 export declare class SkillFilesystemWatcher {
     private readonly targets;
     private readonly onChange;
+    private readonly agentsSkillsDir;
     private disposed;
     constructor(options: SkillFilesystemWatcherOptions);
     watchGlobalSkillsDir(): void;
+    watchAgentsGlobalSkillsDir(): void;
     watchWorkspace(workspaceDir: string): void;
     refreshPrimaryWorkspace(workspaceDir: string): void;
     dispose(): void;

package/dist/src/agent/skills/filesystem-watcher.js

@@ -4,6 +4,7 @@ import { init_logger } from "../../utils/logger.js";
 import { init_paths, resolveSkillsDir } from "../../config/paths.js";
 import { createSkillConfigManager } from "./config.js";
 import { resolveWorkspaceSkillsDir } from "./workspace-skills-dir.js";
+import { resolveAgentsSkillsDir, resolveWorkspaceAgentsSkillsDir } from "./skill-sources.js";
 import { isManagedSkillTransientDirName } from "./managed-store.js";
 import path from "node:path";
 import chokidar from "chokidar";
@@ -41,11 +42,11 @@ function isSameOrInside(parent, child) {
 	return rel === "" || !!rel && !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 function isWorkspaceSkillPath(workspaceRoot, candidate) {
-	const skillsRoot = resolveWorkspaceSkillsDir(workspaceRoot);
-	return candidate === workspaceRoot || isSameOrInside(skillsRoot, candidate) || isSameOrInside(candidate, skillsRoot);
+	const skillsRoots = [resolveWorkspaceSkillsDir(workspaceRoot), resolveWorkspaceAgentsSkillsDir(workspaceRoot)];
+	return candidate === workspaceRoot || skillsRoots.some((skillsRoot) => isSameOrInside(skillsRoot, candidate) || isSameOrInside(candidate, skillsRoot));
 }
 function isWorkspaceSkillsRoot(workspaceRoot, candidate) {
-	return candidate === resolveWorkspaceSkillsDir(workspaceRoot);
+	return candidate === resolveWorkspaceSkillsDir(workspaceRoot) || candidate === resolveWorkspaceAgentsSkillsDir(workspaceRoot);
 }
 function isSkillMdPath(candidate) {
 	return path.basename(candidate).toLowerCase() === "skill.md";
@@ -55,20 +56,27 @@ function readWatcherConfig() {
 	const rawDebounce = cfg.load?.watchDebounceMs;
 	return {
 		enabled: cfg.load?.watch !== false,
+		agentsGlobalEnabled: cfg.load?.sources?.agentsGlobal?.enabled !== false,
 		debounceMs: typeof rawDebounce === "number" && Number.isFinite(rawDebounce) ? Math.max(0, rawDebounce) : DEFAULT_DEBOUNCE_MS
 	};
 }
 var SkillFilesystemWatcher = class {
 	targets = /* @__PURE__ */ new Map();
 	onChange;
+	agentsSkillsDir;
 	disposed = false;
 	constructor(options) {
 		this.onChange = options.onChange;
+		this.agentsSkillsDir = options.agentsSkillsDir ?? resolveAgentsSkillsDir();
 		this.watchGlobalSkillsDir();
+		this.watchAgentsGlobalSkillsDir();
 	}
 	watchGlobalSkillsDir() {
 		this.watchRoot(resolveSkillsDir(), "global");
 	}
+	watchAgentsGlobalSkillsDir() {
+		this.watchRoot(this.agentsSkillsDir, "agents-global");
+	}
 	watchWorkspace(workspaceDir) {
 		const resolved = normalizePath(workspaceDir);
 		if (!resolved) return;
@@ -76,6 +84,7 @@ var SkillFilesystemWatcher = class {
 	}
 	refreshPrimaryWorkspace(workspaceDir) {
 		this.watchGlobalSkillsDir();
+		this.watchAgentsGlobalSkillsDir();
 		this.watchWorkspace(workspaceDir);
 	}
 	dispose() {
@@ -93,10 +102,10 @@ var SkillFilesystemWatcher = class {
 	}
 	watchRoot(root, kind) {
 		if (this.disposed) return;
-		const { enabled, debounceMs } = readWatcherConfig();
+		const { enabled, agentsGlobalEnabled, debounceMs } = readWatcherConfig();
 		const resolvedRoot = normalizePath(root);
 		const key = `${kind}:${resolvedRoot}`;
-		if (!enabled) {
+		if (!enabled || kind === "agents-global" && !agentsGlobalEnabled) {
 			this.unwatch(key);
 			return;
 		}
@@ -159,8 +168,8 @@ var SkillFilesystemWatcher = class {
 		this.targets.delete(key);
 	}
 	scheduleRefresh(target, changedPath) {
-		const { enabled, debounceMs } = readWatcherConfig();
-		if (!enabled) {
+		const { enabled, agentsGlobalEnabled, debounceMs } = readWatcherConfig();
+		if (!enabled || target.kind === "agents-global" && !agentsGlobalEnabled) {
 			this.unwatch(target.key);
 			return;
 		}

package/dist/src/agent/skills/hub-lock.js

@@ -1,5 +1,5 @@
-import { init_paths, resolveSkillsLockPath } from "../../config/paths.js";
 import { init_write_file_atomic, writeTextAtomicSync } from "../../infra/write-file-atomic.js";
+import { init_paths, resolveSkillsLockPath } from "../../config/paths.js";
 import { existsSync, readFileSync } from "node:fs";
 //#region src/agent/skills/hub-lock.ts
 /**