agent-relay-runner 0.113.0 → 0.115.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.113.0",
+  "version": "0.115.0",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -21,7 +21,7 @@
   },
   "dependencies": {
     "agent-relay-providers": "0.104.1",
-    "agent-relay-sdk": "0.2.96",
+    "agent-relay-sdk": "0.2.97",
     "callmux": "0.23.0"
   },
   "devDependencies": {

package/plugins/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "agent-relay-runner",
   "description": "Thin Agent Relay runner bridge for Claude Code",
-  "version": "0.113.0",
+  "version": "0.115.0",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/launch-assembly.ts

@@ -10,6 +10,7 @@ import {
 import {
   projectConfigProjectionOn,
   hostUserScopeMcpServers,
+  profileAllowsHostAssets,
   profileUsesProviderHostGlobals,
   providerHomePathFor,
   providerProvisioningHomePathFor,
@@ -19,6 +20,7 @@ import { claudeLaunchPromptGateSettings } from "./claude-prompt-gates";
 import {
   materializeResolvedAssets,
   resolveClaudeProjectSkills,
+  resolveClaudeHostSkills,
   resolveProjectClaudeSettings,
   resolveClaudeProvisionedPlugins,
   resolveClaudeProvisionedSkills,
@@ -127,10 +129,14 @@ export interface AssembledLaunch {
   skills: AssembledAsset[];
   /** Project `.claude/skills` materialized for this Claude launch (#668). */
   projectSkills: AssembledAsset[];
+  /** Host/global Claude skills explicitly inherited without enabling host MCP. */
+  hostSkills: AssembledAsset[];
   /** Project `.claude/settings.json` sanitized and injected for this Claude launch (#669). */
   projectSettings: { applied: boolean; keys: string[]; ignoredKeys: string[]; file?: string };
   /** Relay-provisioned plugins (Claude --plugin-dir). Empty for Codex (no plugin surface). */
   plugins: AssembledAsset[];
+  /** Host/global provider plugin dirs explicitly inherited without enabling host MCP. */
+  hostPluginDirs: string[];
   mcp: AssembledMcp;
   instructions: AssembledInstructions;
   /** Provider provisioning/vanilla/instruction launch-arg block, in launch order. */
@@ -236,8 +242,11 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   const statusLine = profileAllowsRelayFeature(config, "statusLine");
 
   const skills = configHome ? resolveClaudeProvisionedSkills(configHome, config) : [];
+  const hostSkills = configHome
+    ? resolveClaudeHostSkills(configHome, config, new Set(skills.map((s) => s.name)))
+    : [];
   const projectSkills = configHome
-    ? resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name)))
+    ? resolveClaudeProjectSkills(configHome, config, new Set([...skills, ...hostSkills].map((s) => s.name)))
     : [];
   const projectSettings = resolveProjectClaudeSettings(config);
   const provisionedPlugins = assetHome ? resolveClaudeProvisionedPlugins(assetHome, config) : [];
@@ -249,7 +258,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   //   host plugin dirs → ONLY host-base profiles; isolated/vanilla must not pull them back in.
   const relayPluginDirs = !config.agentProfile && relayPlugin ? [CLAUDE_RELAY_PLUGIN_DIR] : [];
   const provisionedPluginDirs = provisionedPlugins.map((p) => p.dir);
-  const hostPluginDirs = profileUsesProviderHostGlobals(config) ? providerConfig.pluginDirs : [];
+  const hostPluginDirs = profileAllowsHostAssets(config, "plugins") ? providerConfig.pluginDirs : [];
   const pluginDirs = [...new Set([...relayPluginDirs, ...provisionedPluginDirs, ...hostPluginDirs])];
 
   const provisionedMcp = profileProvisioning(config).mcpServers;
@@ -333,6 +342,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     relayPlugin,
     statusLine,
     skills: skills.map((s) => ({ name: s.name, dir: s.dir })),
+    hostSkills: hostSkills.map((s) => ({ name: s.name, dir: s.dir })),
     projectSkills: projectSkills.map((s) => ({ name: s.name, dir: s.dir })),
     projectSettings: {
       applied: projectSettings.applied,
@@ -341,6 +351,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
       ...(projectSettings.file ? { file: projectSettings.file } : {}),
     },
     plugins: provisionedPlugins.map((p) => ({ name: p.name, dir: p.dir })),
+    hostPluginDirs,
     mcp: {
       relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers,
       ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
@@ -410,9 +421,11 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     relayPlugin: false,
     statusLine: false,
     skills: provisionedSkills.map((s) => ({ name: s.name, dir: s.dir })),
+    hostSkills: [],
     projectSkills: [],
     projectSettings: { applied: false, keys: [], ignoredKeys: [] },
     plugins: [],
+    hostPluginDirs: [],
     mcp: {
       relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [],
       ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
@@ -451,7 +464,9 @@ function materializeClaudeAssets(config: RunnerSpawnConfig): void {
   if (configHome) {
     const skills = resolveClaudeProvisionedSkills(configHome, config);
     materializeResolvedAssets(skills);
-    materializeResolvedAssets(resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name))));
+    const hostSkills = resolveClaudeHostSkills(configHome, config, new Set(skills.map((s) => s.name)));
+    materializeResolvedAssets(hostSkills);
+    materializeResolvedAssets(resolveClaudeProjectSkills(configHome, config, new Set([...skills, ...hostSkills].map((s) => s.name))));
   }
   if (assetHome) materializeResolvedAssets(resolveClaudeProvisionedPlugins(assetHome, config));
 }

package/src/profile-home.ts

@@ -18,6 +18,17 @@ export function profileUsesHostProviderGlobals(config: { agentProfile?: RunnerSp
   return !config.agentProfile || config.agentProfile.base === "host";
 }
 
+export function profileAllowsHostAssets(
+  config: { agentProfile?: RunnerSpawnConfig["agentProfile"] },
+  asset: "skills" | "plugins",
+): boolean {
+  return profileUsesProviderHostGlobals(config) || Boolean(config.agentProfile?.hostAssets?.[asset]);
+}
+
+export function profileAllowsHostGlobalInstructions(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
+  return !config.agentProfile || config.agentProfile.instructions.globalInstructions === "allow";
+}
+
 export function projectConfigProjectionOn(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
   return Boolean(config.agentProfile?.projectSkills || config.agentProfile?.projectSettings);
 }
@@ -90,6 +101,7 @@ function prepareProviderHome(provider: SpawnProvider, config: RunnerSpawnConfig)
   const authItems = manifest?.home?.authItems ?? [];
   const sourceHome = providerSourceHome(provider);
   const authLinked = linkExistingAuthItems(sourceHome, target, authItems);
+  linkHostGlobalInstructionFiles(provider, sourceHome, target, config);
   return { path: target, authLinked };
 }
 
@@ -101,14 +113,16 @@ function bootstrapCodexFirstRun(codexHome: string, config: RunnerSpawnConfig): v
 }
 
 function bootstrapClaudeFirstRun(claudeHome: string, config: RunnerSpawnConfig): void {
-  if (profileAllowsRelayFeature(config, "context")) writeClaudeRelayManual(claudeHome);
+  if (profileAllowsRelayFeature(config, "context") && !profileAllowsHostGlobalInstructions(config)) {
+    writeClaudeRelayManual(claudeHome);
+  }
   seedClaudeConfigIfMissing(claudeHome, config);
 }
 
 BOOTSTRAP_HOOKS.set("codex", bootstrapCodexFirstRun);
 BOOTSTRAP_HOOKS.set("claude", bootstrapClaudeFirstRun);
 
-function providerSourceHome(provider: string): string {
+export function providerSourceHome(provider: string): string {
   const manifest = getManifest(provider);
   const envVar = manifest?.home?.configDirEnvVar;
   const configDir = manifest?.home?.configDir ?? `.${provider}`;
@@ -161,15 +175,23 @@ function sanitizePathPart(value: string): string {
 function linkExistingAuthItems(sourceHome: string, targetHome: string, items: string[]): string[] {
   const linked: string[] = [];
   for (const item of items) {
-    const source = join(sourceHome, item);
-    const target = join(targetHome, item);
-    if (!existsSync(source) || existsSync(target)) continue;
-    symlinkSync(source, target);
-    linked.push(item);
+    if (linkExistingPath(join(sourceHome, item), join(targetHome, item))) linked.push(item);
   }
   return linked;
 }
 
+function linkExistingPath(source: string, target: string): boolean {
+  if (!existsSync(source) || existsSync(target)) return false;
+  symlinkSync(source, target);
+  return true;
+}
+
+function linkHostGlobalInstructionFiles(provider: SpawnProvider, sourceHome: string, targetHome: string, config: RunnerSpawnConfig): void {
+  if (!profileAllowsHostGlobalInstructions(config)) return;
+  const files = provider === "claude" ? ["CLAUDE.md"] : provider === "codex" ? ["AGENTS.md"] : [];
+  for (const file of files) linkExistingPath(join(sourceHome, file), join(targetHome, file));
+}
+
 function trustWorkspaceForCodex(codexHome: string, config: RunnerSpawnConfig): void {
   if (!config.cwd) return;
   const path = join(codexHome, "config.toml");

package/src/profile-projection.ts

@@ -33,6 +33,8 @@ export function agentProfileProjectionReport(input: AgentProfileProjectionInput)
   add(hooksEntry(assembled));
   add(provisioningSkillsEntry(assembled));
   add(provisioningPluginsEntry(assembled));
+  add(hostSkillsEntry(assembled));
+  add(hostPluginsEntry(assembled));
   add(provisioningMcpEntry(assembled));
   for (const entry of provisioningSkippedEntries(assembled)) add(entry);
   add(projectMcpEntry(assembled));
@@ -166,6 +168,29 @@ function provisioningPluginsEntry(a: AssembledLaunch): AgentProfileProjectionEnt
   return applied("provisioning.plugins", `${count}`, `Relay-provisioned plugins passed to ${label} via the plugin dir mechanism${names}.`);
 }
 
+function hostSkillsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.hostAssets?.skills);
+  if (!optedIn) return notApplicable("hostAssets.skills", "off", "Host/global skill inheritance is off for this resolved profile.");
+  const label = getManifest(a.provider)?.label ?? a.provider;
+  if (!getManifest(a.provider)?.provisioning?.bundledPlugin) {
+    return notApplicable("hostAssets.skills", "unsupported", `${label} does not expose host skill-dir projection through Agent Relay.`);
+  }
+  if (!a.hostSkills.length) return applied("hostAssets.skills", "none", "Host/global skill inheritance is on, but no valid host skill dirs were found.");
+  const names = a.hostSkills.map((s) => s.name).join(", ");
+  return applied("hostAssets.skills", `${a.hostSkills.length}`, `Host/global skills materialized into Relay's managed ${label} config home (${names}).`);
+}
+
+function hostPluginsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.hostAssets?.plugins);
+  if (!optedIn) return notApplicable("hostAssets.plugins", "off", "Host/global plugin inheritance is off for this resolved profile.");
+  const label = getManifest(a.provider)?.label ?? a.provider;
+  if (!getManifest(a.provider)?.provisioning?.bundledPlugin) {
+    return notApplicable("hostAssets.plugins", "unsupported", `${label} has no plugin-dir surface for host plugin inheritance.`);
+  }
+  if (!a.hostPluginDirs.length) return applied("hostAssets.plugins", "none", "Host/global plugin inheritance is on, but no host plugin dirs are configured.");
+  return applied("hostAssets.plugins", `${a.hostPluginDirs.length}`, `Host/global plugin dirs passed to ${label} (${a.hostPluginDirs.join(", ")}).`);
+}
+
 function provisioningMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
   const names = a.mcp.servers;
   if (!names.length) return notApplicable("provisioning.mcp", "none", "No relay-provisioned MCP servers materialized for this launch.");

package/src/provisioning.ts

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import type { ProvisioningAssetFile, ProvisioningMcpServer, ResolvedProvisioning } from "agent-relay-sdk";
 import type { RunnerSpawnConfig } from "./adapter";
+import { profileAllowsHostAssets, providerSourceHome } from "./profile-home";
 
 // Runner-side materialization of the relay-resolved provisioning bundle
 // (#554/#555/#556). The relay resolves a profile's refs against the DB registry and
@@ -97,6 +98,29 @@ export function resolveClaudeProjectSkills(
   return resolved.sort((a, b) => a.name.localeCompare(b.name));
 }
 
+export function resolveClaudeHostSkills(
+  claudeHome: string,
+  config: Pick<RunnerSpawnConfig, "agentProfile">,
+  reservedNames: ReadonlySet<string> = new Set(),
+): ResolvedAsset[] {
+  if (!profileAllowsHostAssets(config, "skills")) return [];
+  const skillsRoot = join(providerSourceHome("claude"), "skills");
+  if (!existsSync(skillsRoot)) return [];
+  const targetRoot = join(claudeHome, "skills");
+  const resolved: ResolvedAsset[] = [];
+  for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
+    if (!entry.isDirectory() || reservedNames.has(entry.name)) continue;
+    const source = join(skillsRoot, entry.name);
+    if (!existsSync(join(source, "SKILL.md"))) continue;
+    resolved.push({
+      name: entry.name,
+      dir: join(targetRoot, assetDirName(entry.name)),
+      source: { kind: "link", source },
+    });
+  }
+  return resolved.sort((a, b) => a.name.localeCompare(b.name));
+}
+
 const UNSAFE_PROJECT_CLAUDE_SETTINGS = new Set([
   "apiKeyHelper",
   "allowDangerouslySkipPermissions",