@humwick/runner 0.130.5 → 0.130.6

package/src/launch-assembly.ts

@@ -1,4 +1,5 @@
 import { bundledIntegrationAssets, bundledIntegrationHome, suppressOwnedClaudePlugins, selectClaudePluginDirs } from "./provider-integration";
+import { resolveOpenCodeAssets } from "./adapters/opencode-provisioning";
 import { relayEnv, writeChildEnv } from "@humwick/sdk/env";
 import { codexRetiredMcpConfigArgs } from "./adapters/codex-effective-config";
 import { activeSharedMcpServers } from "@humwick/sdk";
@@ -53,7 +54,7 @@ import {
   codexProvisionedMcpArgs,
   codexProvisionedMcpTimeoutArgs,
   openCodeMcpConfigPayload,
-  relayMcpCodexConfigArgs, runnerMcpGeneration,
+  relayMcpCodexConfigArgs,
   sharedMcpMetaOnlyServer,
   writeSharedMcpMetaOnlyConfig,
   SHARED_MCP_METAONLY_CONFIG_FILENAME,
@@ -73,7 +74,7 @@ import {
   type NativeMemoryLever,
 } from "./native-memory-lever";
 
-// #1565 P5.7 — relay's inline `--settings` actually reaches this launch. Same gate
+// P5.7 — relay's inline `--settings` actually reaches this launch. Same gate
 // `claudeSettingsArgs` applies below, passed to the lever so its applied/suppressed report cannot
 // claim a settings key the merge then drops.
 const callerSettingsMergeable = (argLists: string[][], cwd?: string): boolean => {
@@ -81,7 +82,7 @@ const callerSettingsMergeable = (argLists: string[][], cwd?: string): boolean =>
   return !caller || Boolean(caller.settings);
 };
 
-// #557 — THE single launch-assembly contract. Given a resolved AgentProfile (+ its
+// THE single launch-assembly contract. Given a resolved AgentProfile (+ its
 // spawn-time ResolvedProvisioning), `assembleLaunch` produces ONE provider-neutral
 // description of the launch: the relay-provisioned skills/plugins/MCP, the bundled relay
 // surface, the instruction-source disposition, and `base:"vanilla"` as the zero-host
@@ -106,7 +107,7 @@ export interface AssembledInstructions {
   /** Repo CLAUDE.md/AGENTS.md cascade: "allow" left available, "suppressed" by the
    *  vanilla launch mechanism, "reinjected" when the native project scope is dropped (to gate
    *  ambient hooks) but P.instructions re-injects the repo docs through the controlled
-   *  append-system-prompt channel (#2086), "unsupported" requested-but-not-enforced. */
+   *  append-system-prompt channel, "unsupported" requested-but-not-enforced. */
   repo: AssembledInstructionDisposition;
   /** Host/global provider instructions: "allow", "isolated" (dropped by the isolated home), or "unsupported". */
   global: AssembledInstructionDisposition;
@@ -114,47 +115,46 @@ export interface AssembledInstructions {
    *  context) is configured for this launch. `launchContextPending` distinguishes providers that
    *  can only transport it with their first turn from providers that emit it at process launch. */
   systemPromptAppend: boolean;
-  // ── #559 SEAM ──────────────────────────────────────────────────────────────────
-  // Scoped {profile|user} memory does not exist yet (#559 generalizes Projects' anchor
+  // ── SEAM ──────────────────────────────────────────────────────────────────
+  // Scoped {profile|user} memory does not exist yet (generalizes Projects' anchor
   // to project|profile|user). When it lands, the assembled instruction world becomes
   // "instructions + provisioned assets + scoped knowledge": the relay-side composer
   // (composeSpawnInstructions) gains a profile/user-scoped preamble beside the existing
   // project preamble, and THIS field reports which scopes contributed. Until then it is
-  // always "none" — a thin add for #559, not a refactor.
+  // always "none" — a thin add, not a refactor.
   scopedKnowledge: "none";
 }
 
 export interface AssembledMcp {
-  generation?: import("@humwick/sdk").ToolGeneration;
   /** The identity-bearing relay HTTP MCP endpoint is injected. */
   relayEndpoint: boolean;
-  /** Only the assembled servers may load (Claude --strict-mcp-config). #662: true for ALL
+  /** Only the assembled servers may load (Claude --strict-mcp-config).: true for ALL
    *  managed Claude launches so the project `.mcp.json` enable-modal can't wedge a headless
    *  agent; relay's endpoint + provisioned servers (via --mcp-config) are preserved. Always
    *  false for Codex (no equivalent discovery modal). */
   strict: boolean;
   /** Relay-provisioned server names (excludes the relay endpoint itself). */
   servers: string[];
-  /** #667 — project `.mcp.json` server names projected from the spawn cwd's committed
+  /** project `.mcp.json` server names projected from the spawn cwd's committed
    *  `.mcp.json` (via `--mcp-config`, so they survive strict). Sourced from the project,
    *  not ambient host MCP. Empty unless the profile/spawn opted into `projectMcp`, and a
    *  name already declared by relay-provisioned `servers` wins (not double-listed here). */
   projectServers: string[];
-  /** #662/#2075 — host USER-scope MCP server names (`~/.claude.json` `mcpServers`) re-injected
+  /** host USER-scope MCP server names (`~/.claude.json` `mcpServers`) re-injected
    *  into `--mcp-config` for an `mcp.mode:"host"` profile, so `--strict-mcp-config` keeps
    *  the ambient host MCP (callmux/qmd/gh) instead of dropping it. Isolated homes receive the
    *  explicit host cell too; non-host modes stay empty. Codex reports its host config.toml
    *  servers through the same field. */
   hostServers: string[];
-  /** #672 — when the profile/spawn opted into `sharedMcp`, the agent's NON-IDENTITY MCP
+  /** when the profile/spawn opted into `sharedMcp`, the agent's NON-IDENTITY MCP
    *  (tokenlean, github) is routed through one orchestrator-owned shared `callmux` listener via
    *  a per-agent `callmux bridge --cwd "$WORKTREE"` (session-cwd isolation), injected through
    *  the same `--mcp-config` / `-c` channel so it survives strict. `url` is the listener the
    *  bridge connects to. Undefined when projection is OFF (the default). The bridge is opaque
    *  at assembly time — its server SET is owned by the listener config, not enumerated here.
-   *  The identity-bearing relay endpoint is never on the shared listener (#215). #1450 —
+   *  The identity-bearing relay endpoint is never on the shared listener. —
    *  `relayFronted` marks a metaOnly callmux that ALSO fronts the relay endpoint on-demand as a
-   *  second downstream (via the runner proxy, so identity/#215 hold); the relay stays per-agent. */
+   *  second downstream (via the runner proxy, so identity hold); the relay stays per-agent. */
   sharedListener?: { url: string; metaOnly?: boolean; relayFronted?: boolean };
 }
 
@@ -168,10 +168,10 @@ export interface AssembledLaunch {
   vanilla: boolean;
   /** Isolated provider config home (CLAUDE_CONFIG_DIR / CODEX_HOME), or undefined for host base. */
   configHome?: string;
-  /** #1963 N3 — the effective Claude `--setting-sources` this launch emits, or undefined when the
+  /** N3 — the effective Claude `--setting-sources` this launch emits, or undefined when the
    *  flag is ABSENT. Absent means the provider default loads EVERY scope: empirically
    *  `user,project,local` on Claude 2.1.x (measured with a controlled probe — the CLI documents the
-   *  valid sources but not the absent-flag default; see #1963 R1.0). An explicit array names the ONLY
+   *  valid sources but not the absent-flag default; R1.0). An explicit array names the ONLY
    *  scopes that load, so the ambient project (`.claude/settings.json`, repo CLAUDE.md/AGENTS.md) and
    *  local (`.claude/settings.local.json`) scopes are DROPPED. Always undefined for Codex, which has
    *  no `--setting-sources` surface (it suppresses the project doc via `project_doc_max_bytes=0`). */
@@ -185,14 +185,14 @@ export interface AssembledLaunch {
   statusLine: boolean;
   /** Relay-provisioned skills materialized for this launch. */
   skills: AssembledAsset[];
-  /** Project `.claude/skills` materialized for this Claude launch (#668). */
+  /** Project `.claude/skills` materialized for this Claude launch. */
   projectSkills: AssembledAsset[];
   /** Host/global Claude skills explicitly inherited without enabling host MCP. */
   hostSkills: AssembledAsset[];
-  /** Project `.claude/settings.json` stays on Claude's native project-settings path (#669). */
+  /** Project `.claude/settings.json` stays on Claude's native project-settings path. */
   projectSettings: { applied: boolean; keys: string[]; ignoredKeys: string[]; file?: string };
   /** Relay-provisioned hooks materialized for this launch. Empty when hooks were resolved
-   *  but could not be delivered — see `hooksSuppressed` (the anti-lie invariant, #1096). */
+   *  but could not be delivered — see `hooksSuppressed`. */
   hooks: AssembledAsset[];
   /** Host hooks explicitly re-injected into an isolated Claude settings.json. */
   hostHooks: boolean;
@@ -202,19 +202,19 @@ export interface AssembledLaunch {
   projectHooks: AssembledAsset[];
   /** Project hooks requested by the source matrix but denied by the server trust gate. */
   projectHooksSuppressed?: { reason: string };
-  /** #1096 review — set when this launch RESOLVED provisioned hooks (incl. a baseline safety
+  /** review — set when this launch RESOLVED provisioned hooks (incl. a baseline safety
    *  guard) that could NOT be delivered: caller `--settings` was unmergeable (Claude), a
    *  host-base Codex agent has no managed CODEX_HOME, or the installed Codex is too old to
    *  consume hooks.json. Drives a LOUD projection warning so a baseline guard is never
    *  SILENTLY absent while the report says "applied". */
   hooksSuppressed?: { reason: string; names: string[] };
-  /** #1565 P5.7 — the provider-NATIVE-memory lever this launch carries. `policy:"default"` means
+  /** P5.7 — the provider-NATIVE-memory lever this launch carries. `policy:"default"` means
    *  the profile declared nothing: no env/arg/settings key was emitted and the launch is
    *  byte-identical to a pre-P5.7 one. Any other policy renders EXPLICITLY in both directions.
    *  `suppressed` names a lever that was resolved but could not be delivered on this base — the
-   *  `hooksSuppressed` anti-lie precedent (#1096), so a lever is never silently absent. */
+   *  `hooksSuppressed` anti-lie precedent, so a lever is never silently absent. */
   nativeMemory: NativeMemoryLever;
-  /** #1096 review — Claude only: true when the caller's own `--settings` was folded into the
+  /** review — Claude only: true when the caller's own `--settings` was folded into the
    *  relay-emitted `--settings` (relay hooks/statusLine merged in). The adapter
    *  must then STRIP the caller's `--settings` from the provider args so exactly one reaches the
    *  launch. False when relay emitted its own settings standalone or added none. */
@@ -223,11 +223,11 @@ export interface AssembledLaunch {
   plugins: AssembledAsset[];
   /** Host/global provider plugin dirs explicitly inherited without enabling host MCP. */
   hostPluginDirs: string[];
-  /** #3387 — native host plugins (Claude installed-plugin registry ids) this launch's home carries. */
+  /** native host plugins (Claude installed-plugin registry ids) this launch's home carries. */
   hostPlugins: string[];
-  /** #3387 — per host asset class: applied, selected-empty, disabled or unsupported. */
+  /** per host asset class: applied, selected-empty, disabled or unsupported. */
   hostSources: HostSourceReport;
-  /** #3387 — the central provider defaultArgs this launch carries (Settings/defaults class). */
+  /** the central provider defaultArgs this launch carries (Settings/defaults class). */
   hostDefaultArgs: string[];
   mcp: AssembledMcp;
   /** Lower-precedence source assets intentionally omitted from the emitted launch. */
@@ -237,12 +237,12 @@ export interface AssembledLaunch {
   args: string[];
   /** Provisioning-derived env additions (the isolated config-home var). */
   env: Record<string, string>;
-  /** #3025 — whether agent-redact's post-tool hooks reached this launch, and how. */
+  /** whether agent-redact's post-tool hooks reached this launch, and how. */
   redaction: AgentRedactState;
 }
 
 // ── Bundled relay assets (relocated from the adapters so the assembler — not each
-// adapter — owns launch-arg construction; #557). Adapters re-export for test parity. ──
+// adapter — owns launch-arg construction). Adapters re-export for test parity. ──
 
 const CODEX_BUNDLED_SKILLS_DIR = resolve(import.meta.dir, "../plugins/codex/skills");
 
@@ -259,7 +259,7 @@ function codexSkillSources(config: RunnerSpawnConfig) {
   const home = providerHomePathFor("codex", config);
   const provisioned = home ? resolveCodexProvisionedSkills(home, config) : [];
   const bundled = !config.agentProfile && profileAllowsRelayFeature(config, "skills") ? bundledIntegrationAssets(config).map(asset => asset.dir) : [];
-  // #3387 — the managed CODEX_HOME hides the host's own skills; Host Skills on names them as roots,
+  // the managed CODEX_HOME hides the host's own skills; Host Skills on names them as roots,
   // off disables the ambient ones Codex would still discover from HOME.
   const host = home ? codexHostPlan(config, providerSourceHome("codex")) : undefined;
   const hostRoots = host?.skillRoots ?? [];
@@ -271,7 +271,7 @@ export function codexSkillRoots(config: RunnerSpawnConfig): string[] {
   return codexSkillSources(config).roots;
 }
 
-// #552 vanilla base (Codex): suppress the AGENTS.md project-doc cascade. project_doc_max_bytes
+// vanilla base (Codex): suppress the AGENTS.md project-doc cascade. project_doc_max_bytes
 // (default 32768) caps bytes Codex reads from AGENTS.md walking root→cwd; 0 stops before adding
 // any, so no repo (or fresh-CODEX_HOME global) project doc loads. The isolated CODEX_HOME already
 // drops host config.toml MCP/hooks; this closes the cwd-resident repo instruction channel.
@@ -279,14 +279,14 @@ export function codexProjectDocSuppressionArgs(config: Pick<RunnerSpawnConfig, "
   return profileIsVanillaBase(config) ? ["-c", "project_doc_max_bytes=0"] : [];
 }
 
-// #1096 — the settings.json relay WRITES into an isolated managed Claude home so the provisioned
+// the settings.json relay WRITES into an isolated managed Claude home so the provisioned
 // hooks (baseline guard included) land in the DOCUMENTED hook source Claude honors
 // ($CLAUDE_CONFIG_DIR/settings.json — loaded under `--setting-sources "user"` and the default),
 // rather than riding ONLY the inline `--settings` CLI flag. Claude does not document `--settings`
 // as a hook source, and — unlike a file written straight to disk — that flag's JSON must survive
 // shell/tmux launcher transit and passes Claude's "silently ignore settings that fail validation"
 // gate; a written settings.json bypasses both, so the baseline guard can't be silently absent
-// (the #1096 inert-at-runtime symptom). Returns null when:
+// Returns null when:
 //   • there is NO isolated managed home (host base reuses the real ~/.claude — relay must not
 //     clobber it; that path keeps the inline --settings delivery), or
 //   • a caller --settings is present (the merge/suppression path owns hook delivery inline; see
@@ -305,7 +305,7 @@ export function claudeManagedHookSettings(config: RunnerSpawnConfig, configHome:
 
 // ── Instruction disposition (the vanilla floor's effect on the host instruction cascade) ──
 
-// #1963 N1/N3 — the disposition follows the launch FACT, not the profile's declared policy alone.
+// N1/N3 — the disposition follows the launch FACT, not the profile's declared policy alone.
 // `projectScopeDropped` is true whenever the project setting-source is not loaded (Claude
 // `--setting-sources user`, emitted for a vanilla base OR a projectConfigProjection launch; Codex
 // `project_doc_max_bytes=0` for a vanilla base). When it is dropped, the repo CLAUDE.md/AGENTS.md
@@ -316,7 +316,7 @@ export function claudeManagedHookSettings(config: RunnerSpawnConfig, configHome:
 // minimal/isolated base OR a base:"host"+projectConfigProjection agent reports `isolated`, not the
 // old `allow` that lied for the isolated prod reviewer.
 function repoInstructionDisposition(profile: AgentProfile, projectScopeDropped: boolean, reinjected: boolean): AssembledInstructionDisposition {
-  // #2086 — the drop is not silent when P.instructions re-injects the repo docs through the
+  // the drop is not silent when P.instructions re-injects the repo docs through the
   // controlled channel: the cascade is honored, just via append-system-prompt instead of the
   // native project scope. Report that FACT so the anti-lie projection never says "suppressed"
   // for a launch that actually carries the repo instructions.
@@ -328,7 +328,7 @@ function repoInstructionDisposition(profile: AgentProfile, projectScopeDropped:
 }
 
 function globalInstructionDisposition(profile: AgentProfile, isolatedHome: boolean): AssembledInstructionDisposition {
-  // #1963 N1 review (P1): key on whether host globals are ACTUALLY linked, not on is-isolated-home.
+  // N1 review (P1): key on whether host globals are ACTUALLY linked, not on is-isolated-home.
   // `linkHostGlobalInstructionFiles` (profile-home.ts) symlinks the host global CLAUDE.md into the
   // managed home whenever `globalInstructions:"allow"` — even for an isolated base — so "allow" means
   // globals ARE present and reporting "isolated" there would be a false report. Only an `ignore`
@@ -392,7 +392,6 @@ export function openCodeMcpConfigForLaunch(config: RunnerSpawnConfig): Record<st
   const { declaredMcp, relayEndpoint } = resolveOpenCodeDeclaredMcp(config);
   return openCodeMcpConfigPayload({
     relayUrl: config.relayUrl,
-    generation: runnerMcpGeneration(config.env),
     ...(config.relayMcpEndpoint ? { endpoint: config.relayMcpEndpoint } : {}),
     includeRelay: relayEndpoint,
     servers: declaredMcp,
@@ -400,16 +399,16 @@ export function openCodeMcpConfigForLaunch(config: RunnerSpawnConfig): Record<st
 }
 
 interface CodexMcpResolution extends McpSourceSelection {
-  /** #1575 — set when the shared-listener route is served through a per-agent metaOnly callmux
+  /** set when the shared-listener route is served through a per-agent metaOnly callmux
    *  (Codex worker) rather than the plain flat bridge. Carries the exact config path/url/cwd so
-   *  materializeCodexAssets writes the SAME file assembleCodex's descriptor points at. #1450 —
+   *  materializeCodexAssets writes the SAME file assembleCodex's descriptor points at. —
    *  `relay` adds the identity-bearing relay endpoint as a SECOND downstream (via the runner proxy)
    *  when the proxy is active, so the on-demand relay set loads through callmux_call. */
   metaOnlyCallmux?: { configPath: string; url: string; cwd: string; relay?: MetaOnlyRelayDownstream };
 }
 
-// #1575 — a Codex worker swaps the flat shared-listener bridge for a per-agent metaOnly callmux so
-// the ~40 downstream schemas load on demand. Gated exactly like phase C's relay allowlist (#1570):
+// a Codex worker swaps the flat shared-listener bridge for a per-agent metaOnly callmux so
+// the ~40 downstream schemas load on demand. Gated exactly like phase C's relay allowlist:
 // an explicitly worker-classified profile AND a provider whose manifest eager-loads every tool
 // schema (no client-native deferral). Data-driven from the manifest, never a provider-identity
 // branch — Claude (client-defers) never takes this path, coordinators/reviewers keep the flat
@@ -417,7 +416,7 @@ interface CodexMcpResolution extends McpSourceSelection {
 // the host ~/.codex); worker profiles are isolated, so this holds.
 function codexMetaOnlyCallmuxConfigPath(config: RunnerSpawnConfig): string | undefined {
   if (!isCodexLeanWorkerProfile(config.agentProfile?.name)) return undefined;
-  // #3024 — callmux_call reaches every listener tool and callmux has no per-downstream denylist, so a
+  // callmux_call reaches every listener tool and callmux has no per-downstream denylist, so a
   // profile with a web tool off keeps the flat bridge, where Codex's disabled_tools hides it.
   if (disabledSharedWebTools(config).length) return undefined;
   if (!runnerManagedToolDeferralRoute("codex")) return undefined;
@@ -432,14 +431,14 @@ function resolveCodexDeclaredMcp(config: RunnerSpawnConfig): CodexMcpResolution
   const selected = resolveMcpSources(config, hostMcpInjected ? hostCodexMcpServers() : {});
   const { sharedListenerUrl, relayEndpoint } = selected;
   const metaOnlyConfigPath = sharedListenerUrl ? codexMetaOnlyCallmuxConfigPath(config) : undefined;
-  // #1450 — front the relay endpoint on-demand through the SAME metaOnly callmux, but ONLY when the
+  // front the relay endpoint on-demand through the SAME metaOnly callmux, but ONLY when the
   // runner proxy is active (config.relayMcpEndpoint = the proxy URL, config.mcpProxySecret = its
   // secret) AND the profile has the relay endpoint on. Routing through the proxy keeps the live
-  // token off disk (#215). This gate matches runner-core's proxy on-demand-hiding gate exactly, so
+  // token off disk. This gate matches runner-core's proxy on-demand-hiding gate exactly, so
   // the direct client's on-demand tools are hidden ONLY when this front simultaneously exists.
   const metaOnlyRelay: MetaOnlyRelayDownstream | undefined =
     metaOnlyConfigPath && relayEndpoint && config.relayMcpEndpoint && config.mcpProxySecret
-      ? { endpoint: config.relayMcpEndpoint, authSecret: config.mcpProxySecret, generation: runnerMcpGeneration(config.env) }
+      ? { endpoint: config.relayMcpEndpoint, authSecret: config.mcpProxySecret }
       : undefined;
   const metaOnlyCallmux = sharedListenerUrl && metaOnlyConfigPath
     ? { configPath: metaOnlyConfigPath, url: sharedListenerUrl, cwd: config.cwd, ...(metaOnlyRelay ? { relay: metaOnlyRelay } : {}) }
@@ -457,7 +456,7 @@ function resolveCodexDeclaredMcp(config: RunnerSpawnConfig): CodexMcpResolution
 
 // ── Per-provider arg assembly ──────────────────────────────────────────────────────
 
-// #2513 — `provider` parameterizes the claude family: claude-b reuses this assembler whole,
+// `provider` parameterizes the claude family: claude-b reuses this assembler whole,
 // and every home/env derivation (providerHomePathFor, configHomeEnv) keys off the id so its
 // launch resolves the claude-b manifest's configDir instead of claude's.
 function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfig, hostDefaultArgs: string[], provider: string = "claude"): AssembledLaunch {
@@ -467,7 +466,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   const vanilla = profileIsVanillaBase(config);
   const relayPlugin = profileAllowsRelayFeature(config, "plugins");
   const relaySkills = profileAllowsRelayFeature(config, "skills");
-  // #3181 — the status line is how Relay tracks a Claude agent's context, so every profile gets it.
+  // the status line is how Relay tracks a Claude agent's context, so every profile gets it.
   const statusLine = true;
 
   const skillSources = configHome ? resolveClaudeSkillSources(configHome, config, provider) : { relay: [], project: [], host: [], shadows: [] };
@@ -484,7 +483,7 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     ? { reason: config.agentProfile.projectGates?.hooks?.detail ?? "partial — not acknowledged" }
     : undefined;
   const provisionedHookSet = renderProvisionedHookSet([...projectHooks, ...provisionedHooks]);
-  // #1096 — for an isolated managed home with no caller --settings, the provisioned hooks are
+  // for an isolated managed home with no caller --settings, the provisioned hooks are
   // delivered through the managed settings.json (the documented, transit-safe hook source), so
   // keep them OUT of the inline --settings to avoid double-registering the same guard. Host-base
   // and caller-`--settings` launches keep inline delivery (see claudeManagedHookSettings).
@@ -493,21 +492,21 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   const redact = resolveAgentRedact();
   const inlineHookSet = managedHookSettings ? {} : mergeHookSets(mergeHookSets(provisionedHookSet, isAgentRedactInstall(redact) ? redact.claudeHooks : {}), claudeSubagentHooks(config));
   const redaction = isAgentRedactInstall(redact) ? agentRedactOn(managedHookSettings ? "settings.json PostToolUse hooks" : "inline --settings PostToolUse hooks") : redact;
-  // #1565 P5.7 — the native-memory lever. Resolved BEFORE the settings args so its keys can ride
+  // P5.7 — the native-memory lever. Resolved BEFORE the settings args so its keys can ride
   // relay's inline `--settings` (the only settings channel a host-base launch has); the env var
   // below is the one that must always be present, and outranks both settings channels.
   const nativeMemory = resolveClaudeNativeMemoryLever(config, configHome, hostDefaultArgs, (lists) => callerSettingsMergeable(lists, config.cwd), provider);
   const settings = claudeSettingsArgs(
-    { ...projectSettings.settings, ...(relayPlugin ? { enabledPlugins: suppressOwnedClaudePlugins(undefined) } : {}), ...claudeGuardedRelaySettings(config.approvalMode, runnerMcpGeneration(config.env)), ...claudeHostInstructionExcludeSettings(config), ...claudeBypassPermissionSettings(config.approvalMode), ...claudeHarnessTrim(config).settings, ...claudeSubagentSettings(config) },
+    { ...projectSettings.settings, ...(relayPlugin ? { enabledPlugins: suppressOwnedClaudePlugins(undefined) } : {}), ...claudeGuardedRelaySettings(config.approvalMode), ...claudeHostInstructionExcludeSettings(config), ...claudeBypassPermissionSettings(config.approvalMode), ...claudeHarnessTrim(config).settings, ...claudeSubagentSettings(config) },
     inlineHookSet,
     [...projectHooks, ...provisionedHooks].map((h) => h.name),
     statusLine,
     nativeMemory.settings,
-    { cwd: config.cwd, model: config.model, generation: runnerMcpGeneration(config.env) },
+    { cwd: config.cwd, model: config.model },
     hostDefaultArgs,
     config.providerArgs,
   );
-  // The anti-lie invariant (#1096): only report hooks as materialized when they actually reach
+  // The anti-lie invariant: only report hooks as materialized when they actually reach
   // the launch. If the caller's --settings suppressed them, empty the reported set and surface a
   // loud suppression reason instead of an "applied" report.
   const hooksSuppressed = settings.suppressedHookNames.length
@@ -517,21 +516,21 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
 
   // Plugin dirs (--plugin-dir loads explicitly, independent of --setting-sources):
   //   relay-bundled plugin → only when relay.plugins (carries the relay monitor +
-  //     turn-lifecycle hooks #556, not reproducible via settings.json).
-  //   relay-provisioned plugins (#556) → materialized into the isolated home.
+  //     turn-lifecycle hooks, not reproducible via settings.json).
+  //   relay-provisioned plugins → materialized into the isolated home.
   //   host plugin dirs → ONLY host-base profiles; isolated/vanilla must not pull them back in.
   const relayPluginDirs = !config.agentProfile && relayPlugin ? bundledIntegrationAssets(config).map(asset => asset.dir) : [];
   // `force-for-plugin: true` in this tiny plugin takes precedence over a caller or
   // ambient `outputStyle` setting, so a host-base launch is covered too (there is no
   // Relay-owned CLAUDE_CONFIG_DIR in which to write a custom style file).
   const provisionedPluginDirs = provisionedPlugins.map((p) => p.dir);
-  const hostPluginDirs = selectClaudePluginDirs(hostPlan.pluginDirs, runnerMcpGeneration(config.env), relayPlugin);
+  const hostPluginDirs = selectClaudePluginDirs(hostPlan.pluginDirs, relayPlugin);
   const pluginDirs = [...new Set([resolve(import.meta.dir, "../plugins/claude-output-style"), ...relayPluginDirs, ...provisionedPluginDirs, ...hostPluginDirs])];
 
   const { declaredMcp, hostMcp, relayEndpoint, strictMcp, mcpServers, projectServers, hostMcpServers, sharedListenerUrl, sourceShadows: mcpSourceShadows } =
     resolveClaudeDeclaredMcp(config);
 
-  // #1292 — a provisioned/host server's env/headers can carry a literal secret; inline JSON
+  // a provisioned/host server's env/headers can carry a literal secret; inline JSON
   // in --mcp-config lands verbatim in argv (world-readable via ps/proc). Whenever there's a
   // relay-owned scratch dir to write into (any launch with an agentProfile — see
   // providerProvisioningHomePathFor, which gives even host-base profiles a relay-owned dir
@@ -539,12 +538,12 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
   // writes the file this path points at, from the SAME resolveClaudeDeclaredMcp(config) inputs.
   const mcpConfigFilePath = assetHome ? join(assetHome, "mcp-config.json") : undefined;
 
-  // #2067 — derive Claude's native setting-source cascade from the Project cells.
+  // derive Claude's native setting-source cascade from the Project cells.
   // P.mcp and P.skills have their own controlled channels and are intentionally not
   // triggers. The same list drives the instruction disposition report.
   const settingSources = projectSettingSources(config);
   const projectScopeDropped = Boolean(settingSources && !settingSources.includes("project"));
-  // #2086 — when P.hooks forces the project scope off but P.instructions is on, re-inject the repo
+  // when P.hooks forces the project scope off but P.instructions is on, re-inject the repo
   // CLAUDE.md/AGENTS.md through the controlled append-system-prompt channel so the docs are honored
   // rather than silently dropped (see composeSystemPromptAppend / resolveProjectInstructions).
   const promptFile = resolveClaudeSystemPrompt(config, hostDefaultArgs, assetHome);
@@ -562,7 +561,6 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     ...pluginDirs.flatMap((dir) => ["--plugin-dir", dir]),
     ...claudeMcpLaunchArgs({
       relayUrl: config.relayUrl,
-    generation: runnerMcpGeneration(config.env),
       ...(config.relayMcpEndpoint ? { endpoint: config.relayMcpEndpoint } : {}),
       includeRelay: relayEndpoint,
       servers: declaredMcp,
@@ -611,14 +609,14 @@ function assembleClaude(config: RunnerSpawnConfig, providerConfig: ProviderConfi
     hostSources: claudeHostReport(hostPlan, { mcp: hostMcpServers.length > 0, hooks: hostHooks || (!configHome && hostPlan.selection.hooks), skills: hostSkills.length > 0, defaultArgs: hostDefaultArgs.length > 0, env: Object.keys(providerConfig.env ?? {}).length > 0 && hostPlan.selection.settings }),
     hostDefaultArgs,
     mcp: {
-      ...(runnerMcpGeneration(config.env) === "humwick" ? { generation: "humwick" as const } : {}),
+
       relayEndpoint, strict: strictMcp, servers: mcpServers, projectServers, hostServers: hostMcpServers,
       ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
     },
     sourceShadows: [...skillSourceShadows, ...mcpSourceShadows],
     instructions,
     args,
-    env: writeChildEnv({}, { ...configHomeEnv(provider, configHome, config.env), ...nativeMemory.env, ...fffMcpHookEnv(config), ...webToolsEnv(config), ...agentRedactEnv(redaction) }),
+    env: writeChildEnv({}, { ...configHomeEnv(provider, configHome, config.env), ...nativeMemory.env, ...fffMcpHookEnv(config), ...webToolsEnv(config), ...agentRedactEnv(redaction) }, []),
     redaction,
   };
 }
@@ -631,7 +629,7 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
   const { provisioned: provisionedSkills, bundled: bundledSkillDirs, hostRoots, disabled: disabledSkillDirs, roots: skillDirs } = codexSkillSources(config);
   const hostPlan = configHome ? codexHostPlan(config, providerSourceHome("codex")) : undefined;
   const hostSelection = hostSourcesFor(config);
-  // #1096 review, findings 3 & 4 — Codex delivers hooks via CODEX_HOME/hooks.json, so a launch
+  // review, findings 3 & 4 — Codex delivers hooks via CODEX_HOME/hooks.json, so a launch
   // can only carry them when it has an isolated CODEX_HOME (host-base profiles reuse the real
   // ~/.codex, which relay must not clobber) AND the installed Codex is new enough to consume the
   // file. Resolve the profile's hook definitions to decide whether there was anything to deliver;
@@ -643,7 +641,7 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
     ? {
       reason: !configHome
         ? "Codex host-base profile has no managed CODEX_HOME; relay will not overwrite the host ~/.codex/hooks.json, so the baseline guard cannot be delivered"
-        : "installed Codex is older than 0.124 and ignores CODEX_HOME/hooks.json (set AGENT_RELAY_CODEX_VERSION to override the probe)",
+        : "installed Codex is older than 0.124 and ignores CODEX_HOME/hooks.json (set HUMWICK_CODEX_VERSION to override the probe)",
       names: resolvedHookDefs.map((h) => h.name),
     }
     : undefined;
@@ -653,7 +651,7 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
   // unenforceable rather than claiming an artifact the provider ignores.
   const hostHookSet = configHome && hooksSupported && hostSelection.hooks ? hostCodexHooks() : {};
   const hostHooks = Object.keys(hostHookSet).length > 0;
-  // #3025 — redaction rides the `-c` session-flags layer, so host-base launches keep ~/.codex.
+  // redaction rides the `-c` session-flags layer, so host-base launches keep ~/.codex.
   const redact = resolveAgentRedact();
   const redaction: AgentRedactState = !isAgentRedactInstall(redact) ? redact
     : !hooksSupported ? { state: "unavailable", reason: "installed Codex is older than 0.124 and ignores hooks" }
@@ -662,14 +660,14 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
   // Codex has no `--setting-sources`: only a vanilla base drops the ambient project doc
   // (`project_doc_max_bytes=0`); an isolated CODEX_HOME drops host/global config.toml. There is
   // no P.hooks→scope-drop interference here (only a vanilla base suppresses the project doc), so
-  // Codex never re-injects repo instructions (#2086 is Claude's `--setting-sources` surface).
+  // Codex never re-injects repo instructions (is Claude's `--setting-sources` surface).
   const instructions = assembleInstructions(config, {
     projectScopeDropped: vanilla,
     isolatedHome: Boolean(configHome),
     repoInstructionsReinjected: false,
   });
 
-  // #1292 — a provisioned/project server's env can carry a literal secret; `-c
+  // a provisioned/project server's env can carry a literal secret; `-c
   // mcp_servers.<name>.env.<K>=<V>` lands verbatim in argv (world-readable via ps/proc).
   // An ISOLATED CODEX_HOME is a relay-owned per-instance dir Codex actually reads as its
   // config home, so route command/args/url/env through CODEX_HOME/config.toml instead
@@ -681,14 +679,14 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
 
   // The skills/MCP/project-doc block; core launch config (model/approval/listen) stays
   // in the adapter. -c overrides are order-independent, so the assembled block is contiguous.
-  // #1565 P5.7 — Codex's native-memory lever rides the same `-c` argv precedent as the
+  // P5.7 — Codex's native-memory lever rides the same `-c` argv precedent as the
   // project-doc suppressor above it (`-c project_doc_max_bytes=0`). Argv outranks config.toml, so
   // this is the portable/authoritative half; the isolated CODEX_HOME config.toml is the belt.
   const nativeMemory = resolveNativeMemoryLever({ provider: "codex", config, isolatedHome: Boolean(configHome) });
 
   const args = [
     ...bundledSkillConfigArgs(skillDirs, disabledSkillDirs),
-    ...(relayEndpoint ? relayMcpCodexConfigArgs(config.relayUrl, config.relayMcpEndpoint, runnerMcpGeneration(config.env)) : []),
+    ...(relayEndpoint ? relayMcpCodexConfigArgs(config.relayUrl, config.relayMcpEndpoint) : []),
     ...mcpArgs,
     ...codexRetiredMcpConfigArgs(config),
     ...codexProjectDocSuppressionArgs(config),
@@ -732,14 +730,14 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
       : nativeHostReport(),
     hostDefaultArgs,
     mcp: {
-      ...(runnerMcpGeneration(config.env) === "humwick" ? { generation: "humwick" as const } : {}),
+
       relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: hostMcpServers,
       ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl, ...(metaOnlyCallmux ? { metaOnly: true } : {}), ...(metaOnlyCallmux?.relay ? { relayFronted: true } : {}) } } : {}),
     },
     sourceShadows: mcpSourceShadows,
     instructions,
     args,
-    env: writeChildEnv({}, { ...configHomeEnv("codex", configHome), ...webToolsEnv(config), ...agentRedactEnv(redaction) }),
+    env: writeChildEnv({}, { ...configHomeEnv("codex", configHome), ...webToolsEnv(config), ...agentRedactEnv(redaction) }, []),
     redaction,
   };
 }
@@ -748,6 +746,8 @@ function assembleCodex(config: RunnerSpawnConfig, providerConfig: ProviderConfig
 // provider-home asset formats. It still needs a complete projection object: RunnerCore assembles
 // every normal provider before registration and launch-injection reporting.
 function assembleOpenCode(config: RunnerSpawnConfig, provider: string): AssembledLaunch {
+  const assets = resolveOpenCodeAssets(config);
+  const hooks = profileProvisioning(config).hooks ?? [];
   const { relayEndpoint, mcpServers, projectServers, hostMcpServers, sharedListenerUrl, sourceShadows } = resolveOpenCodeDeclaredMcp(config);
   const instructions = assembleInstructions(config, {
     projectScopeDropped: false,
@@ -761,18 +761,17 @@ function assembleOpenCode(config: RunnerSpawnConfig, provider: string): Assemble
     ...(config.agentProfile ? { profile: config.agentProfile } : {}),
     base: config.agentProfile?.base ?? "host",
     vanilla: profileIsVanillaBase(config),
-    // OpenCode has no launch-level instruction field: both independently gated blocks are sent
-    // only with the first initial/inbox turn. Keep availability distinct from an emitted launch
-    // artifact so projection never mistakes configured systemPromptAppend for delivery proof.
-    relayContext: false, relayContextPending: resolveRelayContext({ slug: "relay.context.opencode", config }).available, launchContextPending: Boolean(config.systemPromptAppend?.trim()),
-    relaySkills: false,
+    // Native instructions are system-level context, persistent across turns and session clears.
+    relayContext: assets.context.available,
+    relaySkills: assets.bundled.length > 0,
     relayPlugin: false,
     statusLine: false,
-    skills: [],
+    skills: assets.provisioned.map(({ name, dir }) => ({ name, dir })),
     hostSkills: [],
     projectSkills: [],
     projectSettings: { applied: false, keys: [], ignoredKeys: [] },
     hooks: [],
+    ...(hooks.length ? { hooksSuppressed: { reason: "OpenCode uses native plugins, not Claude/Codex hook command manifests; these hooks were not applied.", names: hooks.map(hook => hook.name) } } : {}),
     hostHooks: false,
     hostHooksEnforceable: false,
     projectHooks: [],
@@ -785,14 +784,14 @@ function assembleOpenCode(config: RunnerSpawnConfig, provider: string): Assemble
     hostSources: { instructions: "unsupported", mcp: "unsupported", hooks: "unsupported", skills: "unsupported", plugins: "unsupported", settings: "unsupported" },
     hostDefaultArgs: [],
     mcp: {
-      ...(runnerMcpGeneration(config.env) === "humwick" ? { generation: "humwick" as const } : {}),
+
       relayEndpoint, strict: false, servers: mcpServers, projectServers, hostServers: hostMcpServers,
       ...(sharedListenerUrl ? { sharedListener: { url: sharedListenerUrl } } : {}),
     },
     sourceShadows,
     instructions,
     args: [],
-    env: writeChildEnv({}, { ...webToolsEnv(config), ...agentRedactEnv(redaction) }),
+    env: writeChildEnv({}, { ...webToolsEnv(config), ...agentRedactEnv(redaction) }, []),
     redaction,
   };
 }
@@ -804,13 +803,13 @@ function configHomeEnv(provider: string, configHome: string | undefined, launchE
   const envVar = manifest?.home?.configDirEnvVar;
   if (!envVar) return {};
   if (configHome) return { [envVar]: configHome };
-  // #2513 review HIGH-1 — a dedicatedHome provider (claude-b) pins the env var at its OWN
+  // review HIGH-1 — a dedicatedHome provider (claude-b) pins the env var at its OWN
   // effective host home even on host-base/profile-less launches, so the provider binary
   // never falls back to the primary family home (~/.claude). The primary providers
   // (claude, codex) keep their historical no-export host-base behavior.
   const hostHome = providerHostConfigHome(provider);
   if (hostHome) return { [envVar]: hostHome };
-  // #772 — a caller passing launchEnv (claude) opts in to pinning the effective dir (launch
+  // a caller passing launchEnv (claude) opts in to pinning the effective dir (launch
   // env, else the runner's) so the session-status probe, which falls back to the runner's
   // value, reads the dir the provider process uses. Unset everywhere stays unpinned.
   if (!launchEnv) return {};
@@ -838,7 +837,7 @@ function materializeClaudeAssets(config: RunnerSpawnConfig, provider: string = "
   if (!configHome) return;
   const hostPlan = claudeHostPlan(config, providerSourceHome(provider));
   const skillSources = resolveClaudeSkillSources(configHome, config, provider);
-  // #3387 — host classes first: drop what an opted-out class left in this reused home, then link
+  // host classes first: drop what an opted-out class left in this reused home, then link
   // the selected ones, before Relay/Project skills claim their names.
   materializeHostAssets(configHome, hostPlan.links, hostPlan.files, skillSources.host.map((skill) => relative(configHome, skill.dir)));
   materializeResolvedAssets(skillSources.relay);
@@ -846,33 +845,32 @@ function materializeClaudeAssets(config: RunnerSpawnConfig, provider: string = "
   materializeResolvedAssets(skillSources.host);
   materializeResolvedAssets(resolveProvisionedHooks(configHome, config));
   materializeResolvedAssets(resolveProjectHooks(config));
-  // #1096 — land the provisioned hooks in the managed home's settings.json (the documented
+  // land the provisioned hooks in the managed home's settings.json (the documented
   // hook source), matching the assembler's decision to keep them out of the inline --settings.
-  // #1565 P5.7 — the native-memory keys ride the SAME file (the isolated-home belt behind the
-  // env lever). #3387 — so do the selected host settings and native plugin enablement: this is
+  // P5.7 — the native-memory keys ride the SAME file (the isolated-home belt behind the
+  // env lever). — so do the selected host settings and native plugin enablement: this is
   // the one writer of the managed settings.json, so nothing later can wipe plugin enablement.
   const managedHookSettings = claudeManagedHookSettings(config, configHome, provider);
   const nativeMemorySettings = claudeManagedNativeMemorySettings(config, configHome, (lists) => callerSettingsMergeable(lists, config.cwd), provider);
-  // T3182 — the SendFeedback deny rides EVERY managed settings.json this launch writes (the
+  // the SendFeedback deny rides EVERY managed settings.json this launch writes (the
   // file-channel belt behind the CLAUDE_CODE_SEND_FEEDBACK=0 env lever, so a stripped env
   // still removes the tool): merged into the full payload AND the belt-retry payload so the
   // retry can never drop it.
-  const withManagedPermissions = (settings: Record<string, unknown>) => withManagedClaudePermissions(settings, config.approvalMode, runnerMcpGeneration(config.env));
+  const withManagedPermissions = (settings: Record<string, unknown>) => withManagedClaudePermissions(settings, config.approvalMode);
   const baseSettings = { ...hostPlan.settings, ...(managedHookSettings ?? {}) };
   // The hook and selected-host halves of this file are NOT best-effort (a missing baseline guard
-  // is a real regression, #1096; a selected host class must never silently vanish, #3387), so
+  // is a real regression; a selected host class must never silently vanish), so
   // only the native-memory contribution is guarded: on a write failure, retry without it.
   if (applyNativeMemoryBelt("the Claude managed settings.json", () => writeClaudeSettingsJson(configHome, withManagedPermissions({ ...baseSettings, ...nativeMemorySettings }))) && Object.keys(baseSettings).length) {
     writeClaudeSettingsJson(configHome, withManagedPermissions(baseSettings));
   }
   materializeResolvedAssets(resolveClaudeProvisionedPlugins(configHome, config));
-  // #1292 — write the file assembleClaude's --mcp-config <path> points at, from the SAME
+  // write the file assembleClaude's --mcp-config <path> points at, from the SAME
   // resolveClaudeDeclaredMcp(config) inputs (see the purity/consistency note there). Keeps
   // provisioned/host-server env/headers secrets out of argv.
   const { declaredMcp, hostMcp, relayEndpoint, strictMcp } = resolveClaudeDeclaredMcp(config);
   const mcpServers = claudeMcpConfigPayload({
     relayUrl: config.relayUrl,
-    generation: runnerMcpGeneration(config.env),
     ...(config.relayMcpEndpoint ? { endpoint: config.relayMcpEndpoint } : {}),
     includeRelay: relayEndpoint,
     servers: declaredMcp,
@@ -893,7 +891,7 @@ function materializeCodexAssets(config: RunnerSpawnConfig): void {
   materializeHostAssets(configHome, hostPlan.links, []);
   writeCodexHostSettings(configHome, hostPlan.settings, tomlInlineValue);
   materializeResolvedAssets(resolveCodexProvisionedSkills(configHome, config));
-  // #1096 review, finding 4 — don't write CODEX_HOME/hooks.json for a Codex that would ignore it;
+  // review, finding 4 — don't write CODEX_HOME/hooks.json for a Codex that would ignore it;
   // keep disk == report (the assembler reports these hooks suppressed for such a launch).
   if (codexHooksSupported(config.providerConfig.command)) {
     const relayHooks = resolveProvisionedHooks(configHome, config);
@@ -902,20 +900,20 @@ function materializeCodexAssets(config: RunnerSpawnConfig): void {
     const hostHookSet = hostPlan.selection.hooks ? hostCodexHooks() : {};
     writeCodexHooksJson(configHome, mergeHookSets(hostHookSet, relayHookSet));
   }
-  // #1292 — write the CODEX_HOME/config.toml sections assembleCodex's non-secret -c
+  // write the CODEX_HOME/config.toml sections assembleCodex's non-secret -c
   // timeout-only overrides expect to find command/args/url/env in (see the mcpArgs branch
   // there). Same resolveCodexDeclaredMcp(config) inputs, so disk == launch.
   const { declaredMcp, metaOnlyCallmux } = resolveCodexDeclaredMcp(config);
   writeCodexMcpServersToml(configHome, declaredMcp);
-  // #1565 P5.7 — the isolated-home belt behind the `-c features.memories=…` argv lever. Same
+  // P5.7 — the isolated-home belt behind the `-c features.memories=…` argv lever. Same
   // resolveNativeMemoryLever inputs assembleCodex used, so disk == launch. No-op for an
   // undeclared profile (`configToml` is empty, so nothing is written). Guarded: never fails the spawn.
   applyNativeMemoryBelt("the Codex CODEX_HOME/config.toml [features] table", () => {
     writeCodexFeaturesToml(configHome, resolveNativeMemoryLever({ provider: "codex", config, isolatedHome: true }).configToml);
   });
-  // #1575/#1450 — write the per-agent metaOnly config the shared-listener descriptor points at
+  // write the per-agent metaOnly config the shared-listener descriptor points at
   // (`callmux --config <path>`), from the SAME resolveCodexDeclaredMcp inputs so disk == launch.
-  // The optional relay downstream (#1450) rides here too, so the on-demand relay front and the
+  // The optional relay downstream rides here too, so the on-demand relay front and the
   // agent's stdio callmux descriptor come from one resolution.
   if (metaOnlyCallmux) {
     writeSharedMcpMetaOnlyConfig(metaOnlyCallmux.configPath, metaOnlyCallmux.url, metaOnlyCallmux.cwd, metaOnlyCallmux.relay);
@@ -934,7 +932,7 @@ export function assembleLaunch(provider: SpawnProvider, config: RunnerSpawnConfi
   const hostDefaultArgs = hostProviderDefaultArgs(config, providerConfig);
   const serviceEnv = serviceAccessLaunchEnv(config);
   const assembled = assembler(config, providerConfig, hostDefaultArgs);
-  return { ...assembled, env: writeChildEnv({}, { ...assembled.env, ...serviceEnv }) };
+  return { ...assembled, env: writeChildEnv({}, { ...assembled.env, ...serviceEnv }, []) };
 }
 
 /**
@@ -944,9 +942,9 @@ export function assembleLaunch(provider: SpawnProvider, config: RunnerSpawnConfi
  * system context also uses a private file for host-base and profile-less launches.
  */
 export function materializeLaunchAssembly(provider: SpawnProvider, config: RunnerSpawnConfig, assembled?: AssembledLaunch): void {
-  // #3830 — every Claude path, including host-base/profile-less, uses a private file.
+  // every Claude path, including host-base/profile-less, uses a private file.
   if (getManifest(provider)?.shim?.kind === "claude-relay") materializeClaudeSystemPrompt((assembled ?? assembleLaunch(provider, config, config.providerConfig)).systemPromptFile);
-  if (!config.agentProfile && runnerMcpGeneration(config.env) === "humwick") {
+  if (!config.agentProfile) {
     const feature = getManifest(provider)?.provisioning?.bundledSkills ? "skills" : "plugins";
     if (profileAllowsRelayFeature(config, feature)) {
       materializeProviderHome(bundledIntegrationHome(config), { provider, profile: "integrations", instanceId: config.instanceId || config.runnerId, agentId: config.agentId });