agent-relay-runner 0.91.3 → 0.91.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-runner",
-  "version": "0.91.3",
+  "version": "0.91.4",
   "description": "Unified provider lifecycle runner for Agent Relay",
   "type": "module",
   "bin": {
@@ -20,7 +20,7 @@
     "directory": "runner"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.70"
+    "agent-relay-sdk": "0.2.71"
   },
   "devDependencies": {
     "@types/bun": "latest",

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.91.3",
+  "version": "0.91.4",
   "agentRelayContracts": {
     "providerPluginProtocol": 1
   }

package/src/adapters/claude.ts

@@ -9,7 +9,7 @@ import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { profileAllowsRelayFeature, type ManagedProcess, type ProviderAdapter, type ProviderConfig, type ProviderStatusUpdate, type RunnerSpawnConfig, type SemanticStatus, type SpawnArgs } from "../adapter";
 import { collectClaudeSessionEvents } from "./claude-transcript";
 import type { SessionEvent } from "../session-insights";
-import { prepareClaudeProfileHome, profileUsesHostProviderGlobals } from "../profile-home";
+import { prepareClaudeProfileHome, profileUsesClaudeHostProviderGlobals } from "../profile-home";
 import { assembleLaunch, materializeLaunchAssembly, sessionStatusLineSettingsArgs } from "../launch-assembly";
 import { claudeProviderMessageText } from "./claude-delivery";
 import { buildRateLimitProviderState, gatedClaudeRateLimitStatus, parseClaudeRateLimitPane } from "../rate-limit";
@@ -223,7 +223,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     // Create + bootstrap + auth-link the isolated config home (no-op for host base) so the
     // assembler's materialize step has somewhere to write the provisioned skills/plugins.
     prepareClaudeProfileHome(config);
-    const defaultArgs = profileUsesHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
+    const defaultArgs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
     // #557 — ONE assembler owns the provisioning/vanilla/instruction launch surface
     // (--setting-sources, --plugin-dir, --mcp-config, status-line, --append-system-prompt);
     // profile-projection describes the SAME assembled result, so report == launch. The
@@ -236,7 +236,7 @@ export class ClaudeAdapter implements ProviderAdapter {
     // Isolated profiles run their own CLAUDE_CONFIG_DIR and must never route through
     // claude-rig — claude-rig resolves host rig config (and a bare `claude-rig` with no
     // rig key just errors out). Only host-base profiles may use claude-rig.
-    const usesClaudeRig = isClaudeRig && profileUsesHostProviderGlobals(config);
+    const usesClaudeRig = isClaudeRig && profileUsesClaudeHostProviderGlobals(config);
     const bypassRigDefaults = config.headless && usesClaudeRig && config.approvalMode !== "open";
     const rigPrefix = usesClaudeRig && !bypassRigDefaults && config.rig ? ["launch", config.rig] : [];
     const command = !usesClaudeRig || bypassRigDefaults || (!config.rig && !findClaudeRigRC(config.cwd))

package/src/launch-assembly.ts

@@ -7,9 +7,16 @@ import {
   type ProviderConfig,
   type RunnerSpawnConfig,
 } from "./adapter";
-import { hostUserScopeMcpServers, profileUsesHostProviderGlobals, providerHomePathFor } from "./profile-home";
+import {
+  claudeProjectConfigProjectionOn,
+  hostUserScopeMcpServers,
+  profileUsesClaudeHostProviderGlobals,
+  providerHomePathFor,
+} from "./profile-home";
 import {
   materializeResolvedAssets,
+  resolveClaudeProjectSkills,
+  resolveProjectClaudeSettings,
   resolveClaudeProvisionedPlugins,
   resolveClaudeProvisionedSkills,
   resolveCodexProvisionedSkills,
@@ -115,6 +122,10 @@ export interface AssembledLaunch {
   statusLine: boolean;
   /** Relay-provisioned skills materialized for this launch. */
   skills: AssembledAsset[];
+  /** Project `.claude/skills` materialized for this Claude launch (#668). */
+  projectSkills: 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[];
   mcp: AssembledMcp;
@@ -161,10 +172,27 @@ function hasSettingsArg(args: string[]): boolean {
 // --settings is already present (caller wins). Relocated from claude.ts (#557).
 export function sessionStatusLineSettingsArgs(...argLists: string[][]): string[] {
   if (argLists.some(hasSettingsArg)) return [];
-  return ["--settings", JSON.stringify({
+  return ["--settings", JSON.stringify(relayStatusLineSettings())];
+}
+
+function relayStatusLineSettings(): Record<string, unknown> {
+  return {
     statusLine: { type: "command", command: "agent-relay context-probe --wrap", refreshInterval: 30 },
     showThinkingSummaries: true,
-  })];
+  };
+}
+
+function claudeSettingsArgs(
+  projectSettings: Record<string, unknown>,
+  includeStatusLine: boolean,
+  ...argLists: string[][]
+): string[] {
+  if (argLists.some(hasSettingsArg)) return [];
+  const settings = {
+    ...projectSettings,
+    ...(includeStatusLine ? relayStatusLineSettings() : {}),
+  };
+  return Object.keys(settings).length ? ["--settings", JSON.stringify(settings)] : [];
 }
 
 // ── Instruction disposition (the vanilla floor's effect on the host instruction cascade) ──
@@ -198,11 +226,16 @@ function assembleInstructions(config: RunnerSpawnConfig): AssembledInstructions
 function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfig, hostDefaultArgs: string[]): AssembledLaunch {
   const configHome = providerHomePathFor("claude", config);
   const vanilla = profileIsVanillaBase(config);
+  const projectConfigProjection = claudeProjectConfigProjectionOn(config);
   const relayPlugin = profileAllowsRelayFeature(config, "plugins");
   const relaySkills = profileAllowsRelayFeature(config, "skills");
   const statusLine = profileAllowsRelayFeature(config, "statusLine");
 
   const skills = configHome ? resolveClaudeProvisionedSkills(configHome, config) : [];
+  const projectSkills = configHome
+    ? resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name)))
+    : [];
+  const projectSettings = resolveProjectClaudeSettings(config);
   const provisionedPlugins = configHome ? resolveClaudeProvisionedPlugins(configHome, config) : [];
 
   // Plugin dirs (--plugin-dir loads explicitly, independent of --setting-sources):
@@ -212,7 +245,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   //   host plugin dirs → ONLY host-base profiles; isolated/vanilla must not pull them back in.
   const relayPluginDirs = relayPlugin ? [CLAUDE_RELAY_PLUGIN_DIR] : [];
   const provisionedPluginDirs = provisionedPlugins.map((p) => p.dir);
-  const hostPluginDirs = profileUsesHostProviderGlobals(config) ? providerConfig.pluginDirs : [];
+  const hostPluginDirs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.pluginDirs : [];
   const pluginDirs = [...new Set([...relayPluginDirs, ...provisionedPluginDirs, ...hostPluginDirs])];
 
   const provisionedMcp = profileProvisioning(config).mcpServers;
@@ -265,7 +298,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   // still excluded) when the launch both uses the host config home AND its mcp mode is host.
   // An isolated/minimal base has its own config home and never had the real host's user MCP,
   // so it stays relay+provisioned only even if a profile sets mode:"host".
-  const usesHostMcp = profileUsesHostProviderGlobals(config)
+  const usesHostMcp = profileUsesClaudeHostProviderGlobals(config)
     && (!config.agentProfile || config.agentProfile.mcp.mode === "host");
   const hostMcp = usesHostMcp ? hostUserScopeMcpServers() : {};
   const hostMcpServers = Object.keys(hostMcp).filter(
@@ -277,7 +310,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   // Launch order matches the historical claude buildSpawnArgs block exactly so existing
   // arg assertions hold: vanilla scope → plugin dirs → MCP → status-line → append.
   const args = [
-    ...(vanilla ? ["--setting-sources", "user"] : []),
+    ...(vanilla || projectConfigProjection ? ["--setting-sources", "user"] : []),
     ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
     ...claudeMcpLaunchArgs({
       relayUrl: config.relayUrl,
@@ -287,7 +320,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
       hostServers: hostMcp,
       strict: strictMcp,
     }),
-    ...(statusLine ? sessionStatusLineSettingsArgs(hostDefaultArgs, config.providerArgs) : []),
+    ...claudeSettingsArgs(projectSettings.settings, statusLine, hostDefaultArgs, config.providerArgs),
     ...(config.systemPromptAppend ? ["--append-system-prompt", config.systemPromptAppend] : []),
   ];
 
@@ -302,6 +335,13 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     relayPlugin,
     statusLine,
     skills: skills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSkills: projectSkills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSettings: {
+      applied: projectSettings.applied,
+      keys: projectSettings.keys,
+      ignoredKeys: projectSettings.ignoredKeys,
+      ...(projectSettings.file ? { file: projectSettings.file } : {}),
+    },
     plugins: provisionedPlugins.map((p) => ({ name: p.name, dir: p.dir })),
     mcp: {
       relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers,
@@ -371,6 +411,8 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
     relayPlugin: false,
     statusLine: false,
     skills: provisionedSkills.map((s) => ({ name: s.name, dir: s.dir })),
+    projectSkills: [],
+    projectSettings: { applied: false, keys: [], ignoredKeys: [] },
     plugins: [],
     mcp: {
       relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: [],
@@ -389,7 +431,7 @@ function assembleCodex(config: RunnerSpawnConfig, _providerConfig: ProviderConfi
  */
 export function assembleLaunch(provider: SpawnProvider, config: RunnerSpawnConfig, providerConfig: ProviderConfig): AssembledLaunch {
   if (provider === "codex") return assembleCodex(config, providerConfig);
-  const hostDefaultArgs = profileUsesHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
+  const hostDefaultArgs = profileUsesClaudeHostProviderGlobals(config) ? providerConfig.defaultArgs : [];
   return assembleClaude(config, providerConfig, hostDefaultArgs);
 }
 
@@ -403,7 +445,9 @@ export function materializeLaunchAssembly(provider: SpawnProvider, config: Runne
   const configHome = providerHomePathFor(provider, config);
   if (!configHome) return;
   if (provider === "claude") {
-    materializeResolvedAssets(resolveClaudeProvisionedSkills(configHome, config));
+    const skills = resolveClaudeProvisionedSkills(configHome, config);
+    materializeResolvedAssets(skills);
+    materializeResolvedAssets(resolveClaudeProjectSkills(configHome, config, new Set(skills.map((s) => s.name))));
     materializeResolvedAssets(resolveClaudeProvisionedPlugins(configHome, config));
     return;
   }

package/src/profile-home.ts

@@ -16,8 +16,18 @@ export function profileUsesHostProviderGlobals(config: { agentProfile?: RunnerSp
   return !config.agentProfile || config.agentProfile.base === "host";
 }
 
-function profileRequiresIsolatedHome(config: RunnerSpawnConfig): boolean {
-  return Boolean(config.agentProfile && config.agentProfile.base !== "host");
+export function claudeProjectConfigProjectionOn(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
+  return Boolean(config.agentProfile?.projectSkills || config.agentProfile?.projectSettings);
+}
+
+export function profileUsesClaudeHostProviderGlobals(config: { agentProfile?: RunnerSpawnConfig["agentProfile"] }): boolean {
+  return profileUsesHostProviderGlobals(config) && !claudeProjectConfigProjectionOn(config);
+}
+
+function profileRequiresIsolatedHome(provider: "claude" | "codex", config: RunnerSpawnConfig): boolean {
+  if (!config.agentProfile) return false;
+  if (config.agentProfile.base !== "host") return true;
+  return provider === "claude" && claudeProjectConfigProjectionOn(config);
 }
 
 // #557 — PURE: the isolated provider config home path a launch WILL use, or undefined
@@ -25,7 +35,7 @@ function profileRequiresIsolatedHome(config: RunnerSpawnConfig): boolean {
 // computes the home this way to report it + build CLAUDE_CONFIG_DIR/skill/plugin paths
 // without side effects; prepare*ProfileHome creates it at the same path at spawn time.
 export function providerHomePathFor(provider: "claude" | "codex", config: RunnerSpawnConfig): string | undefined {
-  if (!profileRequiresIsolatedHome(config)) return undefined;
+  if (!profileRequiresIsolatedHome(provider, config)) return undefined;
   return providerHomePath(provider, config);
 }
 
@@ -56,7 +66,7 @@ const CLAUDE_AUTH_ITEMS = [".credentials.json", "statsig"];
 // instance-keyed home, run the provider-specific first-run bootstrap. The
 // bootstrap step is the only genuinely provider-specific part.
 function prepareProviderHome(provider: "claude" | "codex", config: RunnerSpawnConfig): ProviderHome | undefined {
-  if (!profileRequiresIsolatedHome(config)) return undefined;
+  if (!profileRequiresIsolatedHome(provider, config)) return undefined;
   const target = providerHomePath(provider, config);
   mkdirSync(target, { recursive: true });
   const authLinked = provider === "codex"

package/src/profile-projection.ts

@@ -34,6 +34,8 @@ export function agentProfileProjectionReport(input: AgentProfileProjectionInput)
   add(provisioningPluginsEntry(assembled));
   add(provisioningMcpEntry(assembled));
   add(projectMcpEntry(assembled));
+  add(projectSkillsEntry(assembled));
+  add(projectSettingsEntry(assembled));
   add(sharedMcpEntry(assembled));
   if (profile) add(filesystemEntry(profile));
   add(configHomeEntry(assembled));
@@ -159,14 +161,30 @@ function projectMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
     : `Project .mcp.json servers emitted as -c mcp_servers.* overrides (${names.join(", ")}).`);
 }
 
-// #672 — shared host-listener MCP provenance. `not-applicable` when the profile/spawn didn't
-// opt in (the default); `applied` reports the per-agent `callmux bridge` routing the agent's
-// non-identity MCP (tokenlean, github) through the shared listener it points at. The server SET
-// is owned by the listener config, so this surfaces the route + URL, not an enumerated list.
+function projectSkillsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.projectSkills);
+  if (!optedIn) return notApplicable("projectSkills", "off", "Project .claude/skills projection is off (opt in via the projectSkills profile/spawn option).");
+  if (a.provider !== "claude") return notApplicable("projectSkills", "unsupported", "Project .claude/skills projection applies to Claude launches only.");
+  if (!a.projectSkills.length) return applied("projectSkills", "none", "Project .claude/skills projection is on, but the spawn cwd declared no valid skill dirs.");
+  const names = a.projectSkills.map((s) => s.name).join(", ");
+  return applied("projectSkills", `${a.projectSkills.length}`, `Project .claude skills materialized into Relay's managed Claude config home (${names}); host/global skills are excluded.`);
+}
+
+function projectSettingsEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
+  const optedIn = Boolean(a.profile?.projectSettings);
+  if (!optedIn) return notApplicable("projectSettings", "off", "Project .claude/settings.json projection is off (opt in via the projectSettings profile/spawn option).");
+  if (a.provider !== "claude") return notApplicable("projectSettings", "unsupported", "Project .claude/settings.json projection applies to Claude launches only.");
+  const ignored = a.projectSettings.ignoredKeys.length ? `; ignored security keys: ${a.projectSettings.ignoredKeys.join(", ")}` : "";
+  return applied("projectSettings", a.projectSettings.keys.length ? `${a.projectSettings.keys.length} keys` : "none", `Project .claude/settings.json was sanitized and injected through --settings; Relay approvalMode/permission gates remain authoritative${ignored}.`);
+}
+
+// #672/#689 — shared host-listener MCP provenance. `applied` reports the per-agent `callmux
+// bridge` route. `not-applicable` means the resolved profile kept shared MCP off (for example a
+// zero-host profile, explicit false, or global kill-switch normalization before launch).
 function sharedMcpEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
   const optedIn = Boolean(a.profile?.sharedMcp);
   const listener = a.mcp.sharedListener;
-  if (!optedIn || !listener) return notApplicable("sharedMcp", "off", "Shared host-listener MCP is off (opt in via the sharedMcp profile/spawn option); non-identity MCP is injected per-agent.");
+  if (!optedIn || !listener) return notApplicable("sharedMcp", "off", "Shared host-listener MCP is off for this resolved profile; non-identity MCP is injected per-agent.");
   return applied("sharedMcp", "on", a.provider === "claude"
     ? `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"', injected into --mcp-config (survives --strict-mcp-config); session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`
     : `Non-identity MCP (e.g. tokenlean, github) routed through the shared callmux listener (${listener.url}) via a per-agent 'callmux bridge --cwd "$WORKTREE"' emitted as -c mcp_servers.* overrides; session survives a listener restart, session-cwd isolated. Relay endpoint stays per-agent (#215).`);

package/src/provisioning.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 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";
@@ -74,6 +74,88 @@ export function resolveProjectMcpServers(
   return out;
 }
 
+export function resolveClaudeProjectSkills(
+  claudeHome: string,
+  config: Pick<RunnerSpawnConfig, "agentProfile" | "cwd">,
+  reservedNames: ReadonlySet<string> = new Set(),
+): ResolvedAsset[] {
+  if (!config.agentProfile?.projectSkills) return [];
+  const skillsRoot = join(config.cwd, ".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",
+  "allowedTools",
+  "disabledMcpjsonServers",
+  "disallowedTools",
+  "enableAllProjectMcpServers",
+  "enabledMcpjsonServers",
+  "env",
+  "hooks",
+  "mcpServers",
+  "permissionMode",
+  "permissions",
+  "statusLine",
+  "tools",
+]);
+
+export interface ResolvedProjectClaudeSettings {
+  applied: boolean;
+  settings: Record<string, unknown>;
+  keys: string[];
+  ignoredKeys: string[];
+  file?: string;
+}
+
+export function resolveProjectClaudeSettings(
+  config: Pick<RunnerSpawnConfig, "agentProfile" | "cwd">,
+): ResolvedProjectClaudeSettings {
+  if (!config.agentProfile?.projectSettings) return { applied: false, settings: {}, keys: [], ignoredKeys: [] };
+  const file = join(config.cwd, ".claude", "settings.json");
+  if (!existsSync(file)) return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(file, "utf8"));
+  } catch (err) {
+    console.warn(`project .claude/settings.json projection: failed to parse ${file}: ${(err as Error).message}`);
+    return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { applied: true, settings: {}, keys: [], ignoredKeys: [], file };
+  }
+  const settings: Record<string, unknown> = {};
+  const ignoredKeys: string[] = [];
+  for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+    if (UNSAFE_PROJECT_CLAUDE_SETTINGS.has(key)) {
+      ignoredKeys.push(key);
+      continue;
+    }
+    settings[key] = value;
+  }
+  return {
+    applied: true,
+    settings,
+    keys: Object.keys(settings).sort(),
+    ignoredKeys: ignoredKeys.sort(),
+    file,
+  };
+}
+
 // A resolved provisioning asset: WHERE it lands (`dir`) and HOW it materializes
 // (`source`). `files` writes the inline set into `dir`; `link` symlinks a pre-existing
 // source dir at `dir`; `inPlace` uses the source dir as-is (no write, dir IS the source).

package/src/relay-injection-events.ts

@@ -39,7 +39,9 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
   if (!supportsLaunchAssembly(input.provider)) return events;
   const assembled = assembleLaunch(input.provider, input.config, input.providerConfig);
   const toolCount = assembled.skills.length + assembled.plugins.length + assembled.mcp.servers.length
+    + assembled.projectSkills.length
     + assembled.mcp.projectServers.length
+    + (assembled.projectSettings.applied ? 1 : 0)
     + (assembled.relaySkills ? 1 : 0)
     + (assembled.relayPlugin ? 1 : 0)
     + (assembled.mcp.relayEndpoint ? 1 : 0)
@@ -51,6 +53,8 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
     assembled.statusLine ? "status line" : "",
     assembled.mcp.relayEndpoint ? "relay MCP" : "",
     assembled.skills.length ? `${assembled.skills.length} skill${assembled.skills.length === 1 ? "" : "s"}` : "",
+    assembled.projectSkills.length ? `${assembled.projectSkills.length} project skill${assembled.projectSkills.length === 1 ? "" : "s"}` : "",
+    assembled.projectSettings.applied ? "project settings" : "",
     assembled.plugins.length ? `${assembled.plugins.length} plugin${assembled.plugins.length === 1 ? "" : "s"}` : "",
     assembled.mcp.servers.length ? `${assembled.mcp.servers.length} MCP server${assembled.mcp.servers.length === 1 ? "" : "s"}` : "",
     assembled.mcp.projectServers.length ? `${assembled.mcp.projectServers.length} project MCP server${assembled.mcp.projectServers.length === 1 ? "" : "s"}` : "",
@@ -70,6 +74,8 @@ function launchInjectionEvents(input: RunnerLaunchInjectionInput): KeyedRelayInj
         relayPlugin: assembled.relayPlugin,
         statusLine: assembled.statusLine,
         skills: assembled.skills,
+        projectSkills: assembled.projectSkills,
+        projectSettings: assembled.projectSettings,
         plugins: assembled.plugins,
         mcp: assembled.mcp,
       },

package/src/runner-core.ts

@@ -16,7 +16,7 @@ import { startControlServer, type ControlServer } from "./control-server";
 import { ReplyObligationCache, obligationRequiresExplicitReply, responseCaptureReplyRoute } from "./reply-obligation-cache";
 import { Outbox, type OutboxRecord } from "./outbox";
 import { extractLastAssistantTurn, extractLastAssistantTurnAfterEntry, countTranscriptEntries, extractFinalAssistantMessage, extractFinalAssistantMessageAfterEntry, extractHookAssistantMessage, extractLatestTurnSteps, stepDedupKeys, transcriptLooksComplete } from "./adapters/claude-transcript";
-import { profileUsesHostProviderGlobals } from "./profile-home";
+import { profileUsesClaudeHostProviderGlobals, profileUsesHostProviderGlobals } from "./profile-home";
 import { RELAY_MCP_TOKEN_ENV, relayMcpEndpoint, resolveSharedMcpUrl } from "./relay-mcp";
 import { RelayMcpProxy } from "./relay-mcp-proxy";
 import { runtimeMetadata } from "./version";
@@ -526,7 +526,7 @@ export class AgentRunner {
   private async spawnProvider(opts: { resumeId?: string; suppressPrompt?: boolean } = {}): Promise<ManagedProcess> {
     this.providerSessionId = crypto.randomUUID();
     this.lastTranscriptPath = undefined;
-    const includeProviderGlobals = profileUsesHostProviderGlobals(this.options);
+    const includeProviderGlobals = this.options.provider === "claude" ? profileUsesClaudeHostProviderGlobals(this.options) : profileUsesHostProviderGlobals(this.options);
     const env = {
       ...process.env as Record<string, string>,
       ...(includeProviderGlobals ? this.options.providerConfig.env : {}),