@xopcai/xopc 0.0.225 → 0.0.228

package/dist/packages/gateway-contract/src/turn-outcome.js

@@ -0,0 +1,114 @@
+import { z } from "zod";
+const TurnOutcomeDeliverableKindSchema = z.enum([
+	"document",
+	"spreadsheet",
+	"presentation",
+	"pdf",
+	"image",
+	"video",
+	"audio",
+	"site",
+	"archive",
+	"file"
+]);
+const TurnOutcomeArtifactLocationSchema = z.enum([
+	"workspace",
+	"external_host",
+	"worktree",
+	"remote_runtime",
+	"artifact_store"
+]);
+const TurnOutcomeArtifactAvailabilitySchema = z.enum([
+	"materializing",
+	"available",
+	"expired",
+	"missing",
+	"failed"
+]);
+const TurnOutcomeArtifactCapabilitySchema = z.enum([
+	"preview",
+	"download",
+	"open",
+	"import",
+	"share",
+	"regenerate"
+]);
+const TurnOutcomeDeliverableSchema = z.object({
+	artifactId: z.string().min(1),
+	title: z.string().min(1),
+	kind: TurnOutcomeDeliverableKindSchema,
+	mimeType: z.string().optional(),
+	sizeBytes: z.number().nonnegative().optional(),
+	availability: TurnOutcomeArtifactAvailabilitySchema,
+	location: TurnOutcomeArtifactLocationSchema,
+	capabilities: z.array(TurnOutcomeArtifactCapabilitySchema),
+	uri: z.string().optional(),
+	workspaceRelativePath: z.string().optional(),
+	shareUrl: z.string().url().optional(),
+	thumbnailUrl: z.string().optional(),
+	expiresAt: z.string().optional()
+});
+const TurnOutcomeChangedFileSchema = z.object({
+	path: z.string().min(1),
+	status: z.enum([
+		"added",
+		"modified",
+		"deleted",
+		"renamed"
+	]).optional(),
+	added: z.number().nonnegative().optional(),
+	removed: z.number().nonnegative().optional()
+});
+const TurnOutcomeChangeSetSchema = z.object({
+	changeSetId: z.string().min(1),
+	files: z.array(TurnOutcomeChangedFileSchema),
+	added: z.number().nonnegative(),
+	removed: z.number().nonnegative(),
+	diff: z.string(),
+	diffTruncated: z.boolean().optional(),
+	environment: z.enum([
+		"workspace",
+		"worktree",
+		"remote_runtime"
+	])
+});
+const TurnOutcomeEvidenceSchema = z.object({
+	evidenceId: z.string().min(1),
+	kind: z.enum([
+		"check",
+		"screenshot",
+		"video",
+		"log"
+	]),
+	label: z.string().min(1),
+	status: z.enum([
+		"passed",
+		"failed",
+		"warning"
+	]),
+	durationMs: z.number().nonnegative().optional(),
+	command: z.string().optional(),
+	artifactId: z.string().optional()
+});
+const TurnOutcomeSchema = z.object({
+	version: z.literal(1),
+	outcomeId: z.string().min(1),
+	runId: z.string().min(1),
+	turnId: z.string().min(1),
+	status: z.enum([
+		"succeeded",
+		"partial",
+		"failed"
+	]),
+	summary: z.string().optional(),
+	deliverables: z.array(TurnOutcomeDeliverableSchema),
+	changeSet: TurnOutcomeChangeSetSchema.optional(),
+	evidence: z.array(TurnOutcomeEvidenceSchema),
+	createdAt: z.string()
+});
+function parseTurnOutcome(value) {
+	const parsed = TurnOutcomeSchema.safeParse(value);
+	return parsed.success ? parsed.data : null;
+}
+//#endregion
+export { TurnOutcomeDeliverableSchema, parseTurnOutcome };

package/dist/src/agent/agent-manager.d.ts

@@ -50,7 +50,7 @@ export interface SkillCatalogRuntimeMeta {
 export interface SkillCatalogSnapshot extends SkillCatalogRuntimeMeta {
     catalog: SkillCatalogEntry[];
 }
-export type AgentSkillUnavailableReason = 'agent-denied' | 'disabled' | 'requirements-unmet' | 'model-invocation-disabled';
+export type AgentSkillUnavailableReason = 'agent-denied' | 'disabled' | 'requirements-unmet' | 'model-invocation-disabled' | 'tool-gated';
 export interface AgentSkillAvailabilityEntry extends SkillCatalogEntry {
     availableForCurrentAgent: boolean;
     unavailableReason: AgentSkillUnavailableReason | null;
@@ -235,7 +235,9 @@ export declare class AgentManager implements AgentInstanceGateway {
     getAgentSkillAvailability(agentId: string): AgentSkillAvailabilityPayload;
     getSessionSkillAvailability(sessionKey: string): AgentSkillAvailabilityPayload;
     getSessionWorkspaceTrust(sessionKey: string): WorkspaceTrustState;
+    getWorkspaceTrust(workspacePath: string): WorkspaceTrustState;
     setSessionWorkspaceTrust(sessionKey: string, trusted: boolean): WorkspaceTrustState;
+    setWorkspaceTrust(workspacePath: string, trusted: boolean): WorkspaceTrustState;
     /**
      * After ~/.xopc/skills.json changes (enable/disable), refresh `<available_skills>` on active agents.
      */

package/dist/src/agent/agent-manager.js

@@ -505,7 +505,7 @@ var AgentManager = class {
 			status: rt.skillManager.getStatus()
 		};
 	}
-	buildAgentSkillAvailability(profile, workspaceDir) {
+	buildAgentSkillAvailability(profile, workspaceDir, registeredToolNames) {
 		const cfg = this.config.config;
 		const entry = Array.isArray(cfg.agents?.list) ? cfg.agents.list.find((a) => a && a.enabled !== false && a.id.toLowerCase() === profile.agentId.toLowerCase()) : void 0;
 		const rt = this.workspaceRuntimes.getOrCreate(workspaceDir, profile.agentId);
@@ -513,12 +513,25 @@ var AgentManager = class {
 		const lock = loadSkillsLock();
 		const workspaceLock = loadSkillsLock(resolveWorkspaceSkillsLockPath(workspaceDir));
 		const allow = profile.skillsAllowlist === void 0 ? void 0 : new Set(profile.skillsAllowlist.map((s) => s.toLowerCase()));
+		const tools = registeredToolNames ?? this.toolsFactory.createAllTools({
+			workspace: workspaceDir,
+			profileMarkdownRoot: resolveAgentProfileDir(cfg, profile.agentId),
+			agentId: profile.agentId,
+			disabledTools: profile.tools.denied,
+			getMemoryManager: () => rt.memoryManager,
+			getSkillManager: () => rt.skillManager
+		}).map((tool) => tool.name);
+		const visibleSkillNames = new Set(rt.skillManager.selectSkillsForAgentIndexing({
+			skillAllowlist: profile.skillsAllowlist,
+			registeredToolNames: tools
+		}).map((skill) => skill.name));
 		const skills = rt.skillManager.getSkills().map((s) => {
 			let unavailableReason = null;
 			if (resolveSkillConfig(s, skillsConfig).enabled === false) unavailableReason = "disabled";
 			else if (s.disableModelInvocation) unavailableReason = "model-invocation-disabled";
 			else if (!isSkillEnabled(s, skillsConfig)) unavailableReason = "requirements-unmet";
 			else if (allow !== void 0 && !allow.has(s.name.toLowerCase())) unavailableReason = "agent-denied";
+			else if (!visibleSkillNames.has(s.name)) unavailableReason = "tool-gated";
 			return {
 				...this.skillCatalogEntryFromSkill(s, skillsConfig, lock, workspaceLock, workspaceDir),
 				availableForCurrentAgent: unavailableReason === null,
@@ -543,10 +556,12 @@ var AgentManager = class {
 	}
 	getSessionSkillAvailability(sessionKey) {
 		const profile = resolveEffectiveAgentProfileForSession(this.config.config, sessionKey);
-		return this.buildAgentSkillAvailability(profile, this.getResolvedWorkspaceForSession(sessionKey));
+		return this.buildAgentSkillAvailability(profile, this.getResolvedWorkspaceForSession(sessionKey), this.agents.get(sessionKey)?.registeredToolNames);
 	}
 	getSessionWorkspaceTrust(sessionKey) {
-		const workspacePath = this.getResolvedWorkspaceForSession(sessionKey);
+		return this.getWorkspaceTrust(this.getResolvedWorkspaceForSession(sessionKey));
+	}
+	getWorkspaceTrust(workspacePath) {
 		const required = hasTrustRequiringProjectResources(workspacePath);
 		return {
 			workspacePath,
@@ -556,7 +571,9 @@ var AgentManager = class {
 		};
 	}
 	setSessionWorkspaceTrust(sessionKey, trusted) {
-		const workspacePath = this.getResolvedWorkspaceForSession(sessionKey);
+		return this.setWorkspaceTrust(this.getResolvedWorkspaceForSession(sessionKey), trusted);
+	}
+	setWorkspaceTrust(workspacePath, trusted) {
 		if (!hasTrustRequiringProjectResources(workspacePath)) return {
 			workspacePath,
 			required: false,
@@ -565,7 +582,7 @@ var AgentManager = class {
 		};
 		this.projectTrustStore.set(workspacePath, trusted);
 		this.refreshSkillsAfterTrustChange();
-		return this.getSessionWorkspaceTrust(sessionKey);
+		return this.getWorkspaceTrust(workspacePath);
 	}
 	/**
 	* After ~/.xopc/skills.json changes (enable/disable), refresh `<available_skills>` on active agents.

package/dist/src/agent/lifecycle/timeout-wrapper.d.ts

@@ -14,6 +14,7 @@ export interface TimeoutConfig {
     networkTimeoutMs: number;
     gracefulShutdownMs: number;
 }
+export declare const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS: number;
 declare const DEFAULT_CONFIG: TimeoutConfig;
 export interface TimeoutResult<T> {
     success: boolean;

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

@@ -3,12 +3,13 @@ import { init_logger } from "../../utils/logger.js";
 //#region src/agent/lifecycle/timeout-wrapper.ts
 init_logger();
 const log = createLogger("TimeoutWrapper");
+const DEFAULT_TOOL_EXECUTION_TIMEOUT_MS = 1800 * 1e3;
 const DEFAULT_CONFIG = {
-	defaultTimeoutMs: 300 * 1e3,
-	shellTimeoutMs: 300 * 1e3,
-	readTimeoutMs: 30 * 1e3,
-	writeTimeoutMs: 60 * 1e3,
-	networkTimeoutMs: 60 * 1e3,
+	defaultTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	shellTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	readTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	writeTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
+	networkTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
 	gracefulShutdownMs: 5e3
 };
 /**
@@ -254,4 +255,4 @@ var TimeoutManager = class {
 	}
 };
 //#endregion
-export { DEFAULT_CONFIG as DEFAULT_TIMEOUT_CONFIG, TimeoutError, TimeoutManager, executeWithTimeout, executeWithTimeoutResult, withTimeout };
+export { DEFAULT_CONFIG as DEFAULT_TIMEOUT_CONFIG, DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, TimeoutError, TimeoutManager, executeWithTimeout, executeWithTimeoutResult, withTimeout };

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

@@ -23,6 +23,6 @@ export type ResolvedHttpMcpTransportConfig = ResolvedBaseMcpTransportConfig & {
     };
 };
 export type ResolvedMcpTransportConfig = ResolvedStdioMcpTransportConfig | ResolvedHttpMcpTransportConfig;
-export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 60000;
+export declare const DEFAULT_MCP_REQUEST_TIMEOUT_MS: number;
 export declare function resolveMcpTransportConfig(serverName: string, rawServer: unknown): ResolvedMcpTransportConfig | null;
 export {};

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

@@ -10,7 +10,7 @@ init_logger();
 init_string_coerce();
 const log = createLogger("Mcp:Bundle");
 const DEFAULT_CONNECTION_TIMEOUT_MS = 3e4;
-const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 6e4;
+const DEFAULT_MCP_REQUEST_TIMEOUT_MS = 1800 * 1e3;
 function getConnectionTimeoutMs(rawServer) {
 	if (rawServer && typeof rawServer === "object" && typeof rawServer.connectionTimeoutMs === "number" && rawServer.connectionTimeoutMs > 0) return rawServer.connectionTimeoutMs;
 	return DEFAULT_CONNECTION_TIMEOUT_MS;

package/dist/src/agent/memory/understanding/service.js

@@ -304,6 +304,7 @@ var UserUnderstandingService = class {
 				disclosurePolicy: candidate.disclosurePolicy,
 				confidence: candidate.confidence,
 				statement: content,
+				payload: candidate.payload,
 				createdBy: context.reviewSource === "background" ? "consolidation" : "runtime",
 				changeReason: context.reviewSource === "background" ? "background synthesis" : "explicit user statement",
 				...validFrom !== void 0 ? { validFrom } : {},

package/dist/src/agent/memory/understanding/types.d.ts

@@ -2,6 +2,7 @@ import type { UnderstandingKind, UserUnderstanding } from '../../../user-context
 export interface UnderstandingCandidate {
     kind: UnderstandingKind;
     content: string;
+    payload?: Record<string, unknown>;
     canonicalKey?: string;
     confidence: number;
     importance: number;

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

@@ -6,9 +6,9 @@ import type { Agent } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
 /** Minimum per-turn timeout (1 minute). */
 export declare const MIN_AGENT_TURN_TIMEOUT_MS = 60000;
-/** Maximum per-turn timeout (4 hours), aligned with `maxTaskDurationMs` schema cap. */
+/** Maximum configurable per-turn timeout (24 hours). */
 export declare const MAX_AGENT_TURN_TIMEOUT_MS: number;
-/** Default per-turn timeout (30 minutes). */
+/** Default per-turn timeout (4 hours). */
 export declare const DEFAULT_AGENT_TURN_TIMEOUT_MS: number;
 export declare const DEFAULT_AGENT_ABORT_GRACE_MS = 5000;
 export declare class AgentTurnUnsettledError extends Error {

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

@@ -2,10 +2,10 @@ import { resolveEffectiveAgentManifestForSession } from "../../config/agent-prof
 //#region src/agent/orchestration/run-agent-turn-with-timeout.ts
 /** Minimum per-turn timeout (1 minute). */
 const MIN_AGENT_TURN_TIMEOUT_MS = 6e4;
-/** Maximum per-turn timeout (4 hours), aligned with `maxTaskDurationMs` schema cap. */
-const MAX_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
-/** Default per-turn timeout (30 minutes). */
-const DEFAULT_AGENT_TURN_TIMEOUT_MS = 1800 * 1e3;
+/** Maximum configurable per-turn timeout (24 hours). */
+const MAX_AGENT_TURN_TIMEOUT_MS = 1440 * 60 * 1e3;
+/** Default per-turn timeout (4 hours). */
+const DEFAULT_AGENT_TURN_TIMEOUT_MS = 14400 * 1e3;
 const DEFAULT_AGENT_ABORT_GRACE_MS = 5e3;
 var AgentTurnUnsettledError = class extends Error {
 	constructor(timeoutMs, abortGraceMs) {

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

@@ -109,6 +109,8 @@ export declare class AgentService {
     getSessionSkillAvailability(sessionKey: string): Promise<AgentSkillAvailabilityPayload>;
     getSessionWorkspaceTrust(sessionKey: string): Promise<WorkspaceTrustState>;
     setSessionWorkspaceTrust(sessionKey: string, trusted: boolean): Promise<WorkspaceTrustState>;
+    getWorkspaceTrust(workspacePath: string): WorkspaceTrustState;
+    setWorkspaceTrust(workspacePath: string, trusted: boolean): WorkspaceTrustState;
     getCapabilityCatalog(sessionKey?: string): AgentCapabilityCatalogEntry[];
     getSkillMarkdownSource(skillName: string): SkillMarkdownPreviewPayload | null;
     refreshSkillsAfterDiskChange(): void;

package/dist/src/agent/service.js

@@ -513,6 +513,12 @@ var AgentService = class {
 		await this.sessionHydrator.workspace(sessionKey);
 		return this.agentManager.setSessionWorkspaceTrust(sessionKey, trusted);
 	}
+	getWorkspaceTrust(workspacePath) {
+		return this.agentManager.getWorkspaceTrust(workspacePath);
+	}
+	setWorkspaceTrust(workspacePath, trusted) {
+		return this.agentManager.setWorkspaceTrust(workspacePath, trusted);
+	}
 	getCapabilityCatalog(sessionKey) {
 		return this.agentManager.getCapabilityCatalogForSession(sessionKey);
 	}

package/dist/src/agent/skills/index.d.ts

@@ -1,11 +1,31 @@
 import { type ResolveSkillSourcesOptions } from './skill-sources.js';
 import type { Skill, SkillConfig, SkillDiagnostic, LoadSkillsResult } from './types.js';
+export type WorkspaceSkillSourceState = 'active' | 'missing' | 'disabled' | 'untrusted' | 'invalid';
+export interface WorkspaceSkillSourceStatus {
+    origin: 'xopc-workspace' | 'agents-workspace';
+    rootDir: string;
+    managed: boolean;
+    writable: boolean;
+    state: WorkspaceSkillSourceState;
+}
+export interface WorkspaceSkillInventoryEntry {
+    skill: Skill;
+    effective: boolean;
+    shadowedBy?: Skill['origin']['id'];
+}
+export interface WorkspaceSkillInventoryResult {
+    entries: WorkspaceSkillInventoryEntry[];
+    sources: WorkspaceSkillSourceStatus[];
+    diagnostics: SkillDiagnostic[];
+}
 export declare function loadSkills(options: ResolveSkillSourcesOptions & {
     /** Dependency-injection override for the ~/.agents/skills compatibility root. */
     agentsDir?: string;
 }): LoadSkillsResult;
-/** Discover only skills owned by a workspace, without global or bundled skills. */
-export declare function loadWorkspaceSkills(workspaceDir: string): LoadSkillsResult;
+/** Discover project-owned XOPC and Agents skills with runtime-equivalent trust and precedence. */
+export declare function loadWorkspaceSkillInventory(workspaceDir: string, options: {
+    workspaceTrust: 'trusted' | 'untrusted';
+}): WorkspaceSkillInventoryResult;
 export interface SkillLoader {
     init: (workspace: string, builtin: string | null) => LoadSkillsResult;
     load: () => LoadSkillsResult;

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

@@ -9,7 +9,8 @@ import { parseSkillToolConditions } from "./skill-tool-gating.js";
 import { formatSkillsForPrompt } from "./format-skills-prompt.js";
 import { parseRequiredEnvVarNames } from "./required-env-vars.js";
 import { parseSkillMetadata } from "./parse-skill-metadata.js";
-import { resolveSkillSources, resolveWorkspaceSkillSource } from "./skill-sources.js";
+import { resolveWorkspaceSkillsDir } from "./workspace-skills-dir.js";
+import { resolveSkillSources, resolveWorkspaceAgentsSkillsDir } from "./skill-sources.js";
 import { collectSkillInstallWarnings, formatScanSummary, scanSkillDirectory } from "./scanner.js";
 import { SkillTestFramework, SkillTestRunner, formatTestResults, formatTestResultsJson, formatTestResultsTap } from "./test-framework.js";
 import { basename, dirname, join, relative, sep } from "path";
@@ -119,6 +120,45 @@ function discoverSkills(source, maxSkillFileBytes) {
 		diagnostics
 	};
 }
+function discoverAndMergeSkills(sources, maxSkillFileBytes, initialDiagnostics = []) {
+	const skillMap = /* @__PURE__ */ new Map();
+	const discoveredSkills = [];
+	const diagnostics = [...initialDiagnostics];
+	for (const source of sources) {
+		const discovered = discoverSkills(source, maxSkillFileBytes);
+		diagnostics.push(...discovered.diagnostics);
+		for (const skill of discovered.skills) {
+			discoveredSkills.push(skill);
+			const previous = skillMap.get(skill.name);
+			if (previous) {
+				const winner = skill.origin.priority > previous.origin.priority ? skill : previous;
+				const shadowed = winner === skill ? previous : skill;
+				diagnostics.push({
+					type: "collision",
+					skillName: skill.name,
+					path: winner.filePath,
+					message: `Skill "${skill.name}" from ${winner.origin.id} (${winner.filePath}) shadows ${shadowed.origin.id} (${shadowed.filePath})`
+				});
+			}
+			if (!previous || skill.origin.priority > previous.origin.priority) skillMap.set(skill.name, skill);
+		}
+	}
+	return {
+		skills: [...skillMap.values()],
+		entries: discoveredSkills.map((skill) => {
+			const winner = skillMap.get(skill.name);
+			return winner === skill ? {
+				skill,
+				effective: true
+			} : {
+				skill,
+				effective: false,
+				shadowedBy: winner.origin.id
+			};
+		}),
+		diagnostics
+	};
+}
 function deriveDescriptionFromMarkdown(content) {
 	let fallbackHeading = "";
 	for (const rawLine of content.split(/\r?\n/)) {
@@ -197,40 +237,42 @@ function loadSkills(options) {
 	const skillsConfig = createSkillConfigManager(resolveStateDir()).load();
 	const resolvedSources = resolveSkillSources(options, skillsConfig);
 	const maxSkillFileBytes = resolveMaxSkillFileBytes(skillsConfig);
-	const skillMap = /* @__PURE__ */ new Map();
-	const diagnostics = [...resolvedSources.diagnostics];
-	for (const source of resolvedSources.sources) {
-		const discovered = discoverSkills(source, maxSkillFileBytes);
-		diagnostics.push(...discovered.diagnostics);
-		for (const skill of discovered.skills) {
-			const previous = skillMap.get(skill.name);
-			if (previous) {
-				const winner = skill.origin.priority > previous.origin.priority ? skill : previous;
-				const shadowed = winner === skill ? previous : skill;
-				diagnostics.push({
-					type: "collision",
-					skillName: skill.name,
-					path: winner.filePath,
-					message: `Skill "${skill.name}" from ${winner.origin.id} (${winner.filePath}) shadows ${shadowed.origin.id} (${shadowed.filePath})`
-				});
-			}
-			if (!previous || skill.origin.priority > previous.origin.priority) skillMap.set(skill.name, skill);
-		}
-	}
-	const merged = Array.from(skillMap.values());
+	const merged = discoverAndMergeSkills(resolvedSources.sources, maxSkillFileBytes, resolvedSources.diagnostics);
 	return {
-		skills: merged,
-		prompt: formatSkillsForPrompt(merged, skillsConfig),
-		diagnostics
+		skills: merged.skills,
+		prompt: formatSkillsForPrompt(merged.skills, skillsConfig),
+		diagnostics: merged.diagnostics
 	};
 }
-/** Discover only skills owned by a workspace, without global or bundled skills. */
-function loadWorkspaceSkills(workspaceDir) {
-	const maxSkillFileBytes = resolveMaxSkillFileBytes(createSkillConfigManager(resolveStateDir()).load());
-	const discovered = discoverSkills(resolveWorkspaceSkillSource(workspaceDir), maxSkillFileBytes);
+/** Discover project-owned XOPC and Agents skills with runtime-equivalent trust and precedence. */
+function loadWorkspaceSkillInventory(workspaceDir, options) {
+	const skillsConfig = createSkillConfigManager(resolveStateDir()).load();
+	const resolved = resolveSkillSources({
+		workspaceDir,
+		workspaceTrust: options.workspaceTrust
+	}, skillsConfig);
+	const maxSkillFileBytes = resolveMaxSkillFileBytes(skillsConfig);
+	const workspaceSources = resolved.sources.filter((source) => source.id === "xopc-workspace" || source.id === "agents-workspace");
+	const discovered = discoverAndMergeSkills(workspaceSources, maxSkillFileBytes, resolved.diagnostics);
+	const agentsRoot = resolveWorkspaceAgentsSkillsDir(workspaceDir);
+	const agentsDiagnostic = resolved.diagnostics.find((diagnostic) => diagnostic.type === "warning" && diagnostic.message.includes("agents-workspace"));
+	const agentsEnabled = skillsConfig.load?.sources?.agentsWorkspace?.enabled !== false;
+	const agentsSource = workspaceSources.find((source) => source.id === "agents-workspace");
 	return {
-		skills: discovered.skills,
-		prompt: formatSkillsForPrompt(discovered.skills),
+		entries: discovered.entries,
+		sources: [{
+			origin: "xopc-workspace",
+			rootDir: resolveWorkspaceSkillsDir(workspaceDir),
+			managed: true,
+			writable: true,
+			state: "active"
+		}, {
+			origin: "agents-workspace",
+			rootDir: agentsRoot,
+			managed: false,
+			writable: false,
+			state: !agentsEnabled ? "disabled" : !existsSync(agentsRoot) ? "missing" : agentsSource ? "active" : agentsDiagnostic?.type === "warning" ? "invalid" : "untrusted"
+		}],
 		diagnostics: discovered.diagnostics
 	};
 }
@@ -288,4 +330,4 @@ function createSkillLoader(options = {}) {
 	};
 }
 //#endregion
-export { SkillTestFramework, SkillTestRunner, applySkillEnvOverrides, collectSkillInstallWarnings, createSkillConfigManager, createSkillLoader, findInstallSpec, formatScanSummary, formatTestResults, formatTestResultsJson, formatTestResultsTap, getSkillEnvironment, hasBinary, installSkill, isSkillEnabled, loadSkills, loadWorkspaceSkills, resolveSkillConfig, scanSkillDirectory, validateSkillConfig };
+export { SkillTestFramework, SkillTestRunner, applySkillEnvOverrides, collectSkillInstallWarnings, createSkillConfigManager, createSkillLoader, findInstallSpec, formatScanSummary, formatTestResults, formatTestResultsJson, formatTestResultsTap, getSkillEnvironment, hasBinary, installSkill, isSkillEnabled, loadSkills, loadWorkspaceSkillInventory, resolveSkillConfig, scanSkillDirectory, validateSkillConfig };

package/dist/src/agent/skills/skill-sources.d.ts

@@ -15,4 +15,3 @@ export interface ResolveSkillSourcesResult {
 export declare function resolveSkillSources(options: ResolveSkillSourcesOptions, skillsConfig: SkillsConfig): ResolveSkillSourcesResult;
 export declare function resolveAgentsSkillsDir(env?: NodeJS.ProcessEnv): string;
 export declare function resolveWorkspaceAgentsSkillsDir(workspaceDir: string): string;
-export declare function resolveWorkspaceSkillSource(workspaceDir: string): SkillSourceDescriptor;

package/dist/src/agent/skills/skill-sources.js

@@ -129,15 +129,5 @@ function resolveAgentsSkillsDir(env = process.env) {
 function resolveWorkspaceAgentsSkillsDir(workspaceDir) {
 	return join(workspaceDir, ".agents", "skills");
 }
-function resolveWorkspaceSkillSource(workspaceDir) {
-	return descriptor({
-		id: "xopc-workspace",
-		rootDir: resolveWorkspaceSkillsDir(workspaceDir),
-		priority: PRIORITY.xopcWorkspace,
-		scope: "workspace",
-		managed: true,
-		writable: true
-	});
-}
 //#endregion
-export { resolveAgentsSkillsDir, resolveSkillSources, resolveWorkspaceAgentsSkillsDir, resolveWorkspaceSkillSource };
+export { resolveAgentsSkillsDir, resolveSkillSources, resolveWorkspaceAgentsSkillsDir };

package/dist/src/agent/tools/create-share-tool.js

@@ -226,7 +226,20 @@ function successResult(locale, payload) {
 				isPublic: payload.reachability === "public"
 			}).filter(Boolean).join("\n")
 		}],
-		details: payload
+		details: {
+			...payload,
+			artifacts: [{
+				artifactId: `share:${String(payload.shareUrl ?? "")}`,
+				title: String(payload.title ?? "Shared result"),
+				kind: payload.kind === "site" ? "site" : payload.kind === "zip" ? "archive" : "file",
+				availability: "available",
+				location: "artifact_store",
+				capabilities: payload.kind === "site" ? ["preview", "share"] : ["download", "share"],
+				shareUrl: String(payload.shareUrl ?? ""),
+				...typeof payload.thumbnailUrl === "string" ? { thumbnailUrl: payload.thumbnailUrl } : {},
+				...typeof payload.expiresAt === "string" ? { expiresAt: payload.expiresAt } : {}
+			}]
+		}
 	};
 }
 function errorResult(locale, message) {

package/dist/src/agent/tools/exec-command.js

@@ -4,14 +4,14 @@ import { resolve } from "node:path";
 import { spawn } from "node:child_process";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/tools/exec-command.ts
-const MAX_COMMAND_TIMEOUT_MS = 3e5;
-const DEFAULT_TIMEOUT_MS = 12e4;
+const MAX_COMMAND_TIMEOUT_MS = 14400 * 1e3;
+const DEFAULT_TIMEOUT_MS = 1800 * 1e3;
 const DEFAULT_MAX_OUTPUT_CHARS = 5e4;
 const STREAM_DELTA_MAX_CHARS = 16e3;
 const ExecCommandSchema = Type.Object({
 	cmd: Type.String({ description: "Shell command to execute." }),
 	cwd: Type.Optional(Type.String({ description: "Working directory. Relative paths are resolved under the agent workspace." })),
-	timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Defaults to 120000 and is capped at 300000." })),
+	timeoutMs: Type.Optional(Type.Number({ description: "Command timeout in milliseconds. Defaults to 1800000 (30m) and is capped at 14400000 (4h)." })),
 	maxOutputChars: Type.Optional(Type.Number({ description: "Maximum characters returned to the model. UI streaming still receives output deltas." }))
 });
 function clampTimeoutMs(raw) {

package/dist/src/agent/tools/execute-code-tool.js

@@ -12,7 +12,7 @@ const MAX_TIMEOUT_SEC = 14400;
 const ExecuteCodeSchema = Type.Object({
 	code: Type.String({ description: "JavaScript to run. Exposed as `tools` (async functions) and `console`:\n  await tools.web_search(query, count?)\n  await tools.web_fetch(url, maxChars?)\n  await tools.read_file(path, limit?)\n  await tools.write_file(path, content)\n  await tools.grep(pattern, { path?, glob?, ignoreCase?, literal?, context?, limit? })\n  await tools.find(pattern, { path?, limit? })\n  await tools.exec_command(cmd, cwd?)\n\nUse console.log() for output; combined stdout/stderr is returned." }),
 	timeout: Type.Optional(Type.Number({
-		description: "Execution timeout in seconds (default: 3600 = 60m, max: 14400 = 4h)",
+		description: "Execution timeout in seconds (default: 1800 = 30m, max: 14400 = 4h)",
 		default: DEFAULT_TIMEOUT_SEC
 	}))
 });

package/dist/src/agent/tools/executor.js

@@ -1,13 +1,13 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { TimeoutError, executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
+import { DEFAULT_TOOL_EXECUTION_TIMEOUT_MS, TimeoutError, executeWithTimeout } from "../lifecycle/timeout-wrapper.js";
 import { withRetry } from "../../infra/retry.js";
 import { ToolConcurrencyController, resolveToolLockMode } from "./concurrency.js";
 //#region src/agent/tools/executor.ts
 init_logger();
 const log = createLogger("ToolExecutor");
 const DEFAULT_CONFIG = {
-	defaultTimeoutMs: 300 * 1e3,
+	defaultTimeoutMs: DEFAULT_TOOL_EXECUTION_TIMEOUT_MS,
 	maxRetries: 2,
 	retryDelayMs: 1e3,
 	enableTimeout: true,

package/dist/src/agent/tools/image-generate-tool.js

@@ -296,6 +296,18 @@ function createImageGenerateTool(options) {
 						paths,
 						workspaceRelativePaths,
 						media,
+						artifacts: media.map((item, index) => ({
+							artifactId: item.id,
+							title: item.name,
+							kind: "image",
+							mimeType: item.mimeType,
+							sizeBytes: item.size,
+							availability: "available",
+							location: "artifact_store",
+							capabilities: ["preview", "download"],
+							uri: item.uri,
+							workspaceRelativePath: workspaceRelativePaths[index]
+						})),
 						attempts: result.attempts,
 						...result.normalization ? { normalization: result.normalization } : {},
 						...result.ignoredOverrides.length > 0 ? { ignoredOverrides: result.ignoredOverrides } : {},

package/dist/src/agent/tools/send-media.js

@@ -64,6 +64,17 @@ function createSendMediaTool(workspace, bus, getContext) {
 					}],
 					details: {
 						media: [media],
+						artifacts: [{
+							artifactId: media.id,
+							title: media.name,
+							kind: media.type === "photo" ? "image" : media.type === "video" ? "video" : media.type === "audio" ? "audio" : media.mimeType === "application/pdf" ? "pdf" : "file",
+							mimeType: media.mimeType,
+							sizeBytes: media.size,
+							availability: "available",
+							location: "artifact_store",
+							capabilities: ["preview", "download"],
+							uri: media.uri
+						}],
 						...p.caption ? { caption: p.caption } : {}
 					}
 				};

package/dist/src/agent/tools/xopc-use-tool.js

@@ -6,6 +6,7 @@ import { ObjectLinkService } from "../../activity/service.js";
 import "../../activity/index.js";
 import { getDefaultAgentId, init_resolve_route } from "../../routing/resolve-route.js";
 import { TaskRepository } from "../../tasks/task-repository.js";
+import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
 import { TaskRunRepository } from "../../tasks/task-run-repository.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { TaskCommandSchema, TaskContextInputSchema } from "../../../packages/gateway-contract/src/tasks.js";
@@ -15,7 +16,6 @@ import "../../automations/index.js";
 import { isValidProjectAgentId, normalizeProjectAgentId, resolveProjectAgentId } from "../../projects/project-agent.js";
 import "../../projects/index.js";
 import { TaskContextRepository } from "../../tasks/task-context-repository.js";
-import { enqueueTaskChangedEvent } from "../../tasks/task-change-events.js";
 import { TaskDependencyError, TaskDependencyService } from "../../tasks/task-dependency-service.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { defineTaskContract } from "../../tasks/task-contract-definition.js";