@humwick/runner 0.130.5 → 0.130.6

package/src/profile-projection.ts

@@ -6,7 +6,8 @@ import type {
   AgentProfileProjectionTrust,
   SpawnProvider,
 } from "@humwick/sdk";
-import { isRecord, mcpServerInfo } from "@humwick/sdk";
+import { isRecord, MCP_SERVER_INFO } from "@humwick/sdk";
+import { SHARED_PROFILE_CAPABILITIES, STORED_NAMES } from "@humwick/sdk/stored-names";
 import { getManifest } from "@humwick/providers";
 import type { AssembledLaunch } from "./launch-assembly";
 import { projectSourceEnabled, type ResolvedSourceShadow } from "./provisioning";
@@ -23,10 +24,10 @@ interface AgentProfileProjectionInput {
   generatedAt?: number;
 }
 
-type MatrixSource = "host" | "project" | "agent-relay";
+type MatrixSource = "host" | "project" | typeof STORED_NAMES.source;
 type MatrixCapability = "instructions" | "mcp" | "hooks" | "skills" | "plugins";
 
-const MATRIX_SOURCES: readonly MatrixSource[] = ["host", "project", "agent-relay"];
+const MATRIX_SOURCES: readonly MatrixSource[] = ["host", "project", STORED_NAMES.source];
 const MATRIX_CAPABILITIES: readonly MatrixCapability[] = ["instructions", "mcp", "hooks", "skills", "plugins"];
 
 export function agentProfileProjectionReport(input: AgentProfileProjectionInput): AgentProfileProjectionReport {
@@ -72,11 +73,11 @@ function matrixEntries(a: AssembledLaunch): AgentProfileProjectionEntry[] {
     "project.hooks": projectHooks(a),
     "project.skills": projectSkills(a),
     "project.plugins": projectPlugins(a),
-    "agent-relay.instructions": relayInstructions(a),
-    "agent-relay.mcp": relayMcp(a),
-    "agent-relay.hooks": relayHooks(a),
-    "agent-relay.skills": relaySkills(a),
-    "agent-relay.plugins": relayPlugins(a),
+    [SHARED_PROFILE_CAPABILITIES.instructions]: relayInstructions(a),
+    [SHARED_PROFILE_CAPABILITIES.mcp]: relayMcp(a),
+    [SHARED_PROFILE_CAPABILITIES.hooks]: relayHooks(a),
+    [SHARED_PROFILE_CAPABILITIES.skills]: relaySkills(a),
+    [SHARED_PROFILE_CAPABILITIES.plugins]: relayPlugins(a),
   };
   addCrossSourceShadows(cells, a);
   return MATRIX_SOURCES.flatMap((source) => MATRIX_CAPABILITIES.map((capability) => cells[`${source}.${capability}`]));
@@ -93,10 +94,11 @@ function addCrossSourceShadows(
   a: AssembledLaunch,
 ): void {
   for (const shadow of a.sourceShadows ?? []) {
-    const entry = cells[`${shadow.source}.${shadow.capability === "hooks" ? "hooks" : shadow.capability}`];
-    const provenance = shadow.source === "agent-relay"
+    const source = shadow.source;
+    const entry = cells[`${source}.${shadow.capability}`];
+    const provenance = source === STORED_NAMES.source
       ? relayProvenance(a, sourceKind(shadow.capability), shadow.name)
-      : shadow.source;
+      : source;
     entry.shadowed = dedupeAssets([...(entry.shadowed ?? []), asset(shadow.name, provenance)]);
   }
 }
@@ -159,7 +161,7 @@ function hostPlugins(a: AssembledLaunch): AgentProfileProjectionEntry {
 
 function projectInstructions(a: AssembledLaunch): AgentProfileProjectionEntry {
   if (a.instructions.repo === "allow") return scalarCell("project.instructions", "allow", "applied", "allow", projectInstructionMechanism(a), "Project/repo instructions remain available.");
-  // #2086 — the native project scope was dropped to gate ambient hooks, but P.instructions
+  // the native project scope was dropped to gate ambient hooks, but P.instructions
   // re-injected the repo CLAUDE.md/AGENTS.md through the controlled append-system-prompt channel.
   // Report it as applied+honored (trusted), NOT suppressed, so the launch shape is not misreported.
   if (a.instructions.repo === "reinjected") return scalarCell("project.instructions", "allow", "applied", "reinjected", "controlled append-system-prompt re-injection", "Repo CLAUDE.md/AGENTS.md are re-injected through Relay's controlled channel because the native project scope is dropped to gate ambient hooks.", "trusted");
@@ -204,40 +206,40 @@ function projectPlugins(a: AssembledLaunch): AgentProfileProjectionEntry {
 
 function relayInstructions(a: AssembledLaunch): AgentProfileProjectionEntry {
   if (a.relayContextPending || a.launchContextPending) {
-    return scalarCell("agent-relay.instructions", "enabled", "applied", "pending first provider turn", "runner provider-delivery injection", "Relay-authored instructions are available and will be prepended to the first provider turn; no provider turn has been emitted at launch.");
+    return scalarCell(SHARED_PROFILE_CAPABILITIES.instructions, "enabled", "applied", "pending first provider turn", "runner provider-delivery injection", "Relay-authored instructions are available and will be prepended to the first provider turn; no provider turn has been emitted at launch.");
   }
   const active = a.relayContext || a.instructions.systemPromptAppend;
-  return scalarCell("agent-relay.instructions", active ? "enabled" : "disabled", active ? "applied" : "disabled", active ? "injected" : "off", "runner context/prompt injection", active ? "Relay-authored instructions reached the provider turn." : "No Relay-authored instruction material was emitted.");
+  return scalarCell(SHARED_PROFILE_CAPABILITIES.instructions, active ? "enabled" : "disabled", active ? "applied" : "disabled", active ? "injected" : "off", "runner context/prompt injection", active ? "Relay-authored instructions reached the provider turn." : "No Relay-authored instruction material was emitted.");
 }
 
 function relayMcp(a: AssembledLaunch): AgentProfileProjectionEntry {
   const assets = [
-    ...(a.mcp.relayEndpoint ? [asset(mcpServerInfo(a.mcp.generation ?? "relay").name, "reserved")] : []),
+    ...(a.mcp.relayEndpoint ? [asset(MCP_SERVER_INFO.name, "reserved")] : []),
     ...a.mcp.servers.map((name) => asset(name, relayProvenance(a, "mcp", name))),
   ];
-  return assetCell("agent-relay.mcp", assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "Relay MCP endpoint / controlled MCP config", assets.length ? `Relay MCP assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay MCP asset reached this launch.", relayShadows(a, "mcp", assets), "trusted");
+  return assetCell(SHARED_PROFILE_CAPABILITIES.mcp, assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "Relay MCP endpoint / controlled MCP config", assets.length ? `Relay MCP assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay MCP asset reached this launch.", relayShadows(a, "mcp", assets), "trusted");
 }
 
 function relayHooks(a: AssembledLaunch): AgentProfileProjectionEntry {
-  if (a.hooksSuppressed?.names.length) return assetCell("agent-relay.hooks", "enabled", "partial", [], "hook delivery withheld", `Relay hooks were resolved but suppressed: ${a.hooksSuppressed.reason}.`, [], "trusted");
+  if (a.hooksSuppressed?.names.length) return assetCell(SHARED_PROFILE_CAPABILITIES.hooks, "enabled", "partial", [], "hook delivery withheld", `Relay hooks were resolved but suppressed: ${a.hooksSuppressed.reason}.`, [], "trusted");
   const assets = a.hooks.map((item) => asset(item.name, relayProvenance(a, "hook", item.name)));
-  return assetCell("agent-relay.hooks", assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "provider hook settings/hooks.json", assets.length ? `Relay hooks reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay hook reached this launch.", relayShadows(a, "hook", assets), "trusted");
+  return assetCell(SHARED_PROFILE_CAPABILITIES.hooks, assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "provider hook settings/hooks.json", assets.length ? `Relay hooks reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay hook reached this launch.", relayShadows(a, "hook", assets), "trusted");
 }
 
 function relaySkills(a: AssembledLaunch): AgentProfileProjectionEntry {
   const assets = [
-    ...(a.relaySkills ? [asset("agent-relay", "bundled")] : []),
+    ...(a.relaySkills ? [asset("humwick", "bundled")] : []),
     ...a.skills.map((item) => asset(item.name, relayProvenance(a, "skill", item.name))),
   ];
-  return assetCell("agent-relay.skills", assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "bundled skills config / Relay plugin", assets.length ? `Relay skill assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay skill asset reached this launch.", relayShadows(a, "skill", assets), "trusted");
+  return assetCell(SHARED_PROFILE_CAPABILITIES.skills, assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "bundled skills config / Relay plugin", assets.length ? `Relay skill assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay skill asset reached this launch.", relayShadows(a, "skill", assets), "trusted");
 }
 
 function relayPlugins(a: AssembledLaunch): AgentProfileProjectionEntry {
   const assets = [
-    ...(a.relayPlugin ? [asset(getManifest(a.provider)?.provisioning?.bundledPlugin?.ref ?? "agent-relay", "bundled")] : []),
+    ...(a.relayPlugin ? [asset(getManifest(a.provider)?.provisioning?.bundledPlugin?.ref ?? "humwick", "bundled")] : []),
     ...a.plugins.map((item) => asset(item.name, relayProvenance(a, "plugin", item.name))),
   ];
-  return assetCell("agent-relay.plugins", assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "provider plugin-dir launch args", assets.length ? `Relay plugin assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay plugin asset reached this launch.", relayShadows(a, "plugin", assets), "trusted");
+  return assetCell(SHARED_PROFILE_CAPABILITIES.plugins, assets.length ? "enabled" : "disabled", assets.length ? "applied" : "disabled", assets, "provider plugin-dir launch args", assets.length ? `Relay plugin assets reached the launch (${assets.map((item) => item.name).join(", ")}).` : "No Relay plugin asset reached this launch.", relayShadows(a, "plugin", assets), "trusted");
 }
 
 function relayStatusLineEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
@@ -249,7 +251,7 @@ function configHomeEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
 }
 
 function launchShapeEntry(a: AssembledLaunch): AgentProfileProjectionEntry {
-  // #2367 — argv can contain the full system prompt and inlined config. The old cell copied that
+  // argv can contain the full system prompt and inlined config. The old cell copied that
   // string into requested, effective, and detail, turning a ~68 KiB launch into ~203 KiB of static
   // agent meta that every status frame then carried through a read/merge/stringify/write cycle.
   // The projection is diagnostic, not the launch authority: retain its useful shape/size facts and
@@ -356,7 +358,7 @@ function relaySourceKindTiers(a: AssembledLaunch): Record<"skill" | "plugin" | "
     .filter((value): value is { source: string; ref: string } => isRecord(value) && value.source === "relay" && typeof value.ref === "string" && !skippedMcpRefs.has(value.ref))
     .map((value) => value.ref);
   return {
-    skill: { reserved: [], registry: relayRegistryRefs(profile?.skills), bundled: a.relaySkills ? ["agent-relay"] : [] },
+    skill: { reserved: [], registry: relayRegistryRefs(profile?.skills), bundled: a.relaySkills ? ["humwick"] : [] },
     plugin: { reserved: [], registry: relayRegistryRefs(profile?.plugins), bundled: a.relayPlugin && provisioning?.bundledPlugin ? [provisioning.bundledPlugin.ref] : [] },
     hook: { reserved: bundledHooks.filter((hook) => hook.baseline).map((hook) => hook.ref), registry: relayRegistryRefs(profile?.hooks?.refs), bundled: bundledHooks.filter((hook) => !hook.baseline).map((hook) => hook.ref) },
     mcp: { reserved: a.mcp.relayEndpoint ? [RELAY_MCP_SERVER_NAME] : [], registry: mcpRegistry, bundled: [] },

package/src/project-instructions.ts

@@ -12,7 +12,7 @@ import { projectSettingSourcesOn } from "./profile-home";
 const REPO_INSTRUCTION_FILES = ["CLAUDE.md", "AGENTS.md"] as const;
 
 // Bound each re-injected file so a pathological repo doc cannot balloon the context.
-// The composed append travels by private file (#3830). Mirrors Codex's
+// The composed append travels by private file. Mirrors Codex's
 // project_doc_max_bytes default; oversized content is truncated with a loud marker
 // rather than silently dropped.
 const REPO_INSTRUCTIONS_MAX_BYTES = 64 * 1024;
@@ -32,7 +32,7 @@ export interface ComposedSystemPromptAppend {
 }
 
 /**
- * Fold the caller's `systemPromptAppend` together with any #2086 repo re-injection into the single
+ * Fold the caller's `systemPromptAppend` together with any repo re-injection into the single
  * `--append-system-prompt` value the launch emits. The two channels are distinct in reporting
  * (relay-authored append vs. repo-doc re-injection), so `reinjected` is returned separately.
  */
@@ -45,7 +45,7 @@ export function composeSystemPromptAppend(config: Pick<RunnerSpawnConfig, "agent
 }
 
 /**
- * #2086 — the instructions sibling of {@link resolveProjectHooks}. When `P.hooks` is
+ * the instructions sibling of {@link resolveProjectHooks}. When `P.hooks` is
  * named, the runner drops the ENTIRE native project setting-source scope so ambient repo
  * hooks can never bypass the trust gate (profile-home `projectSettingSourcesOn`). That drop
  * also strips the repo CLAUDE.md/AGENTS.md cascade even when `P.instructions` is on, silently
@@ -106,14 +106,14 @@ export function projectInstructionsReinjected(config: Pick<RunnerSpawnConfig, "a
 }
 
 const REPO_INSTRUCTIONS_PREAMBLE =
-  "[agent-relay] The repository instruction docs below are re-injected by Relay because the " +
+  "[humwick] The repository instruction docs below are re-injected by Relay because the " +
   "native project setting-source scope was dropped to gate ambient project hooks. Follow them " +
   "as the repository's CLAUDE.md/AGENTS.md guidance.";
 
 function renderRepoInstructionBlock(name: string, content: string): string {
   const bytes = Buffer.byteLength(content, "utf8");
   const body = bytes > REPO_INSTRUCTIONS_MAX_BYTES
-    ? `${Buffer.from(content, "utf8").subarray(0, REPO_INSTRUCTIONS_MAX_BYTES).toString("utf8")}\n[agent-relay: ${name} truncated at ${REPO_INSTRUCTIONS_MAX_BYTES} bytes]`
+    ? `${Buffer.from(content, "utf8").subarray(0, REPO_INSTRUCTIONS_MAX_BYTES).toString("utf8")}\n[humwick: ${name} truncated at ${REPO_INSTRUCTIONS_MAX_BYTES} bytes]`
     : content.replace(/\s+$/, "");
   return `<repo-instructions source="${name}">\n${body}\n</repo-instructions>`;
 }

package/src/provider-auth-warning.ts

@@ -0,0 +1,17 @@
+import { hostname } from "node:os";
+import type { RunnerSpawnConfig } from "./adapter";
+import type { RunnerTimelineEvent } from "./turn-reconcile-event";
+
+/** Claude's status command resolves file/keychain auth without Relay inspecting credentials. */
+export function localClaudeOAuthWarning(config: Pick<RunnerSpawnConfig, "provider" | "agentId" | "instanceId">): RunnerTimelineEvent {
+  const host = hostname();
+  return {
+    status: "provider.auth.local_oauth_fallback",
+    id: `local-oauth-${config.instanceId}-${crypto.randomUUID()}`,
+    timestamp: Date.now(),
+    title: "Claude is using the host's local OAuth login",
+    body: `Host ${host}, agent ${config.agentId}, provider ${config.provider}: no effective CLAUDE_CODE_OAUTH_TOKEN. Claude reports a local OAuth login (Claude config home or platform keychain). This agent will use the host login's account and quota. Restore the provider's injected CLAUDE_CODE_OAUTH_TOKEN and restart the agent to use the intended account.`,
+    icon: "ti-alert-triangle",
+    metadata: { eventType: "provider.auth.local_oauth_fallback", severity: "warning", host, agentId: config.agentId, provider: config.provider, authSource: "local-oauth" },
+  };
+}

package/src/provider-double.ts

@@ -54,6 +54,6 @@ export function primaryProviderInvocation(provider: SpawnProvider, spawnArgs: Sp
     logicalCommand: spawnArgs.command,
     argv: [...spawnArgs.args],
     cwd: spawnArgs.cwd,
-    env: writeChildEnv({}, { ...spawnArgs.env }),
+    env: writeChildEnv({}, { ...spawnArgs.env }, []),
   };
 }

package/src/provider-hold.ts

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import type { Message } from "@humwick/sdk";
 
 /**
- * #2619 — the provider hold/resume state machine: ONE owner for "the provider refused input, hold,
+ * the provider hold/resume state machine: ONE owner for "the provider refused input, hold,
  * resume exactly once". Pure (no I/O); runner-core drives it and does the delivery.
  *
  * State: the active hold EPISODE (id, or none) and ONE parked queue of refused input. Every
@@ -53,10 +53,10 @@ export function resumeWakeEpisode(message: Message): string | undefined {
   return typeof id === "string" && id ? id : undefined;
 }
 
-export const PROVIDER_HELD_REDELIVERY_NOTE = "[agent-relay] Redelivered after a provider usage-limit hold: the provider refused this message before you could act on it, so it may already appear earlier in your conversation unanswered. Handle it now, exactly once.";
+export const PROVIDER_HELD_REDELIVERY_NOTE = "[humwick] Redelivered after a provider usage-limit hold: the provider refused this message before you could act on it, so it may already appear earlier in your conversation unanswered. Handle it now, exactly once.";
 
 /** A late refusal (the turn started, then the provider refused a later call) does not prove the input never ran. */
-export const PROVIDER_HELD_LATE_REDELIVERY_NOTE = "[agent-relay] Redelivered after a provider usage-limit hold: the provider cut off the turn for this message partway, so you may already have acted on part of it. Check what is already done and continue only the unfinished work, then answer once.";
+export const PROVIDER_HELD_LATE_REDELIVERY_NOTE = "[humwick] Redelivered after a provider usage-limit hold: the provider cut off the turn for this message partway, so you may already have acted on part of it. Check what is already done and continue only the unfinished work, then answer once.";
 
 export type ResumeDecision = { action: "settle" } | { action: "continue" } | { action: "replay"; messages: Message[] };
 

package/src/provider-home-marker.ts

@@ -1,3 +1,3 @@
-// Re-export shim (#2547) — the marker moved to the SDK so the runner (writer), the server
+// Re-export shim — the marker moved to the SDK so the runner (writer), the server
 // reaper and the per-orchestrator-host reaper script share one implementation.
 export * from "@humwick/sdk/provider-home-marker";

package/src/provider-home-tombstone.ts

@@ -1,4 +1,4 @@
-// Re-export shim (#2547) — tombstone naming + spawn-side reclaim moved to the SDK so the
+// Re-export shim — tombstone naming + spawn-side reclaim moved to the SDK so the
 // runner, the server reaper and the per-orchestrator-host reaper script share one
 // implementation of the quarantine name-spaces.
 export * from "@humwick/sdk/provider-home-tombstone";

package/src/provider-input-queue.ts

@@ -1,4 +1,4 @@
-// One agent, ONE provider input stream (#1565 F1).
+// One agent, ONE provider input stream.
 //
 // Every payload the runner hands to a provider — a relay message batch, an injected prompt, a
 // self-resume continuation, a memory preamble — ends up in the same place: the provider's single
@@ -60,7 +60,7 @@ export class ProviderInputQueue {
     this.stuckAfterMs = options.stuckAfterMs ?? DEFAULT_STUCK_AFTER_MS;
     if (options.onStuck) this.onStuck = options.onStuck;
     // Capture native timers: another subsystem's synchronous timer shim must not expire
-    // a freshly granted slot and feed an immediate delivery/re-arm loop (#2668).
+    // a freshly granted slot and feed an immediate delivery/re-arm loop.
     this.schedule = options.schedule ?? ((fn, ms) => {
       const timer = setTimeout(fn, ms);
       timer.unref();

package/src/provider-integration.ts

@@ -1,4 +1,4 @@
-// #3470 — bounded provider bridge; project owned metadata, never user assets or physical paths.
+// bounded provider bridge; project owned metadata, never user assets or physical paths.
 import { readFileSync } from "node:fs";
 import { basename, join, resolve } from "node:path";
 import { getManifest } from "@humwick/providers";
@@ -6,8 +6,7 @@ import { sanitizeFsName } from "@humwick/sdk/fs-name";
 import type { RunnerSpawnConfig } from "./adapter";
 import type { ResolvedAsset } from "./provisioning";
 import { providerHomeRootFromEnv } from "./config";
-import { runnerMcpGeneration } from "./relay-mcp";
-import { isRecord, mcpServerInfo, wireToolName, wireToolText, type ProvisioningAssetFile, type ToolGeneration } from "@humwick/sdk";
+import { isRecord, MCP_SERVER_INFO, registryToolName, type ProvisioningAssetFile } from "@humwick/sdk";
 
 export const CLAUDE_OWNED_PLUGIN_IDS = ["agent-relay@agent-relay", "humwick@humwick"];
 const OWNED_PLUGIN_NAMES = new Set(["agent-relay", "agent-relay-runner", "humwick", "humwick-runner"]);
@@ -17,14 +16,19 @@ function ownedClaudePluginName(dir: string): string | undefined {
   catch { return undefined; }
 }
 
-export function selectClaudePluginDirs(dirs: string[], generation: ToolGeneration, ownedProvided: boolean): string[] {
+export function selectClaudePluginDirs(dirs: string[], ownedProvided: boolean): string[] {
   const entries = [...new Set(dirs)].map(dir => ({ dir, name: ownedClaudePluginName(dir) }));
-  const owned = ownedProvided ? undefined : entries.find(entry => entry.name === mcpServerInfo(generation).name || entry.name === `${mcpServerInfo(generation).name}-runner`) ?? entries.find(entry => entry.name);
+  const owned = ownedProvided ? undefined : entries.find(entry => entry.name === MCP_SERVER_INFO.name || entry.name === `${MCP_SERVER_INFO.name}-runner`) ?? entries.find(entry => entry.name);
   return entries.filter(entry => !entry.name || entry === owned).map(entry => entry.dir);
 }
 
-export function providerIntegrationFiles(name: string, files: ProvisioningAssetFile[], generation: ToolGeneration): ProvisioningAssetFile[] {
-  if (generation === "relay" || !(name === "agent-relay-claude-plugin" || name.startsWith("agent-relay-codex-"))) return files;
+export function canonicalIntegrationAssetName(name: string): string {
+  return name.replace(/^agent-relay-/, "humwick-");
+}
+
+export function providerIntegrationFiles(name: string, files: ProvisioningAssetFile[]): ProvisioningAssetFile[] {
+  const canonicalName = canonicalIntegrationAssetName(name);
+  if (!(canonicalName === "humwick-claude-plugin" || canonicalName.startsWith("humwick-codex-") || canonicalName.startsWith("humwick-opencode-"))) return files;
   return files.map(file => {
     if (file.path === ".claude-plugin/plugin.json") {
       const manifest = JSON.parse(file.content);
@@ -33,7 +37,7 @@ export function providerIntegrationFiles(name: string, files: ProvisioningAssetF
       return { ...file, content: JSON.stringify(manifest, null, 2) };
     }
     if (!file.path.endsWith(".md")) return file;
-    return { ...file, content: wireToolText(file.content, generation)
+    return { ...file, content: file.content
       .replace(/\bAgent Relay\b/g, "Humwick")
       .replace(/(?<![\w/.-])agent-relay(?![\w/.-])/g, "humwick") };
   });
@@ -43,8 +47,6 @@ const bundleCache = new Map<string, ProvisioningAssetFile[]>();
 
 // The same manifest overrides as registry seeding make relocated monitors self-contained.
 export function bundledIntegrationAsset(config: RunnerSpawnConfig, source: string, name: string): ResolvedAsset {
-  const generation = runnerMcpGeneration(config.env);
-  if (generation === "relay") return { name, dir: source, source: { kind: "inPlace" } };
   let files = bundleCache.get(source);
   if (!files) {
     const descriptor = getManifest(config.provider)?.provisioning?.bundledPlugin;
@@ -55,7 +57,7 @@ export function bundledIntegrationAsset(config: RunnerSpawnConfig, source: strin
     bundleCache.set(source, files);
   }
   return { name, dir: join(bundledIntegrationHome(config), basename(source)),
-    source: { kind: "files", files: providerIntegrationFiles(name, files, generation) } };
+    source: { kind: "files", files: providerIntegrationFiles(name, files) } };
 }
 
 export function bundledIntegrationAssets(config: RunnerSpawnConfig): ResolvedAsset[] {
@@ -82,12 +84,12 @@ export function bundledIntegrationHome(config: RunnerSpawnConfig): string {
   return join(providerHomeRootFromEnv(), config.provider, "integrations", sanitizeFsName(config.instanceId || config.runnerId));
 }
 
-export function projectClaudePermissionRules(settings: Record<string, unknown>, generation: ToolGeneration): Record<string, unknown> {
+export function projectClaudePermissionRules(settings: Record<string, unknown>): Record<string, unknown> {
   if (!isRecord(settings.permissions)) return settings;
   const permissions = { ...settings.permissions };
   for (const kind of ["allow", "deny", "ask"]) {
     if (Array.isArray(permissions[kind])) permissions[kind] = permissions[kind].map(rule => typeof rule === "string"
-      ? rule.replace(/^mcp__(?:agent-relay|humwick)__(.*)$/, (_match, tool) => `mcp__${mcpServerInfo(generation).name}__${wireToolName(tool, generation)}`) : rule);
+      ? rule.replace(/^mcp__(?:agent-relay|humwick)__(.*)$/, (_match, tool) => `mcp__${MCP_SERVER_INFO.name}__${registryToolName(tool)}`) : rule);
   }
   return { ...settings, permissions };
 }

package/src/provider-setup.ts

@@ -1,19 +1,31 @@
 import { errMessage } from "@humwick/sdk";
 import { checkProviderAuth } from "@humwick/sdk/provider-probe";
 import { selectProviderConfigEnv } from "@humwick/sdk/child-env";
+import { getManifest } from "@humwick/providers";
 import type { ProviderAdapter, ProviderStatusEvent } from "./adapter";
 import { logger } from "./logger";
 import { hostSourcesFor } from "./host-asset-plan";
 import { resolveLaunchCommand } from "./provider-command";
+import { localClaudeOAuthWarning } from "./provider-auth-warning";
 
-/** All real adapters share the managed-spawn login check, including replacements (#3751). */
+/** All real adapters share the managed-spawn login check, including replacements. */
 export function withProviderSetup(adapter: ProviderAdapter): ProviderAdapter {
   const spawn = adapter.spawn.bind(adapter);
   adapter.spawn = async (config) => {
+    const manifest = getManifest(config.provider);
+    const claudeOAuth = manifest?.probe?.authCheck?.command === "claude" && !manifest.apiAuth;
+    // probe the artifact we will actually launch, after home and credential isolation.
+    if (claudeOAuth) config = await adapter.hydrateSpawnConfig?.(config) ?? config;
+    const prepared = claudeOAuth ? adapter.buildSpawnArgs(config, config.providerConfig) : undefined;
     const env = selectProviderConfigEnv(config.providerConfig.env, hostSourcesFor(config).settings);
-    const auth = await checkProviderAuth(config.provider, undefined, env, resolveLaunchCommand(config.providerConfig.command), config.env);
+    const auth = await checkProviderAuth(config.provider, undefined, env, prepared?.command ?? resolveLaunchCommand(config.providerConfig.command), config.env, prepared?.env);
     if (!auth.ok) throw new Error(auth.reason);
-    return spawn(config);
+    if (prepared && !prepared.env.CLAUDE_CODE_OAUTH_TOKEN?.trim() && auth.authSource === "local-oauth") {
+      const warning = localClaudeOAuthWarning(config);
+      console.warn(`${warning.title}: ${warning.body}`);
+      config.onLaunchWarning?.(warning);
+    }
+    return spawn(config, prepared);
   };
   return adapter;
 }

package/src/providers.ts

@@ -14,7 +14,7 @@ interface RunnerProviderRegistration {
 
 const RUNNER_PROVIDERS: Record<string, RunnerProviderRegistration> = {
   claude: { provider: "claude", createAdapter: (args, mode) => createClaudeTransportAdapter("claude", args, mode) },
-  // #2513 — claude-b reuses the Claude adapter under its own id (the OpenCodeAdapter/zai
+  // claude-b reuses the Claude adapter under its own id (the OpenCodeAdapter/zai
   // pattern): same binary and launch wiring, its own manifest home/credential.
   "claude-b": { provider: "claude-b", createAdapter: (args, mode) => createClaudeTransportAdapter("claude-b", args, mode) },
   "claude-api": { provider: "claude-api", createAdapter: () => new ClaudeApiAdapter() },

package/src/provisioning.ts

@@ -1,12 +1,11 @@
 import { providerIntegrationFiles, projectClaudePermissionRules } from "./provider-integration";
-import { runnerMcpGeneration } from "./relay-mcp";
 import { writeChildEnv } from "@humwick/sdk/env";
 import { createHash, randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, realpathSync, renameSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { homedir } from "node:os";
 import { sanitizeFsName } from "@humwick/sdk/fs-name";
-import { RETIRED_SHARED_MCP_SERVER_NAMES, isRelayMcpServerName, mcpServerInfo, wireToolName, type ToolGeneration, coerceProjectMcpServer, fffMcpBinaryPath, PROJECT_MCP_FILE, profileProjectSourceEnabled } from "@humwick/sdk";
+import { RETIRED_SHARED_MCP_SERVER_NAMES, isRelayMcpServerName, MCP_SERVER_INFO, coerceProjectMcpServer, fffMcpBinaryPath, PROJECT_MCP_FILE, profileProjectSourceEnabled } from "@humwick/sdk";
 import { getManifest } from "@humwick/providers";
 import type { ProvisioningAssetFile, ProvisioningHookSet, ProvisioningMcpServer, ResolvedProvisioning } from "@humwick/sdk";
 import type { RunnerSpawnConfig } from "./adapter";
@@ -17,11 +16,11 @@ import { profileAllowsHostGlobalInstructions, providerSourceHome } from "./profi
 import { hostSourcesFor, skillDirsUnder } from "./host-asset-plan";
 
 // Runner-side materialization of the relay-resolved provisioning bundle
-// (#554/#555/#556). The relay resolves a profile's refs against the DB registry and
+// The relay resolves a profile's refs against the DB registry and
 // attaches the concrete definitions to profile.provisioning; here we turn those into
 // real on-disk dirs (skills/plugins). MCP is handled in relay-mcp.ts.
 //
-// #557 — split into PURE RESOLUTION (resolve* → where each asset lands, no writes) and
+// split into PURE RESOLUTION (resolve* → where each asset lands, no writes) and
 // MATERIALIZATION (materialize* → the disk writes). The single launch assembler
 // (launch-assembly.ts) calls the resolvers to build BOTH the launch args and the
 // projection report, so what's reported can never drift from what's written; the
@@ -38,11 +37,11 @@ export function profileProvisioning(config: Pick<RunnerSpawnConfig, "agentProfil
 
 // The fff search-redirect hook is bundled per provider manifest; it only needs the binary path in env.
 function providerBundlesFffRedirect(provider: RunnerSpawnConfig["provider"]): boolean {
-  return Boolean(getManifest(provider)?.provisioning?.bundledHooks?.some((hook) => hook.ref === "agent-relay-fff-search-redirect"));
+  return Boolean(getManifest(provider)?.provisioning?.bundledHooks?.some((hook) => hook.ref === "humwick-fff-search-redirect"));
 }
 
-// #2729 — provisioned stdio commands authored on another host are swapped for this host's
-// provisioned descriptor or dropped here, never emitted broken. #2809 — the fff path rewrite
+// provisioned stdio commands authored on another host are swapped for this host's
+// provisioned descriptor or dropped here, never emitted broken. The fff path rewrite
 // lives here too so every provider launch gets it before the preflight judges the path.
 export function launchProvisionedMcpServers(
   config: Pick<RunnerSpawnConfig, "agentProfile">,
@@ -59,8 +58,8 @@ export function launchProvisionedMcpServers(
 }
 
 export function fffMcpHookEnv(config: Pick<RunnerSpawnConfig, "agentProfile" | "provider">): Record<string, string> {
-  return writeChildEnv({}, { AGENT_RELAY_FFF_MCP_BINARY: providerBundlesFffRedirect(config.provider)
-    ? launchProvisionedMcpServers(config).fff?.command ?? "" : "" });
+  return writeChildEnv({}, { HUMWICK_FFF_MCP_BINARY: providerBundlesFffRedirect(config.provider)
+    ? launchProvisionedMcpServers(config).fff?.command ?? "" : "" }, []);
 }
 
 /** The resolved source matrix decides project MCP/skill projection (see profileProjectSourceEnabled). */
@@ -80,13 +79,13 @@ export function projectSettingsEnabled(config: Pick<RunnerSpawnConfig, "agentPro
   return Boolean(config.agentProfile?.projectSettings);
 }
 
-// #667 — project `.mcp.json` MCP projection. OPT-IN via the resolved profile's `projectMcp`
+// project `.mcp.json` MCP projection. OPT-IN via the resolved profile's `projectMcp`
 // (set per-spawn or by profile, relay-side). Reads the spawn cwd's COMMITTED `.mcp.json` and
 // returns its `mcpServers` as a provider-neutral record, so the launch assembler injects them
 // through the CONTROLLED `--mcp-config` (Claude) / `-c mcp_servers.*` (Codex) path that
 // survives `--strict-mcp-config` — the project's own servers travel with the repo like they do
 // for a human who clones it, WITHOUT enabling Claude's ambient project-discovery trust modal
-// (which wedges headless agents, the reason #662 made every managed launch strict). The runner
+// (which wedges headless agents, the reason made every managed launch strict). The runner
 // is the filesystem authority for the spawn cwd (relay may run on another host), so the read
 // lands here. Best-effort: a missing/malformed file (or one with no `mcpServers`) yields {} and
 // never aborts the launch. Returns {} when projection is OFF.
@@ -99,7 +98,7 @@ export function resolveProjectMcpServers(
   // server decides roots/pinned/any against its registry and carries the result
   // through the spawn-scoped profile. Missing/denied decisions fail closed.
   if (profile?.sources?.project && !profile.projectGates?.mcp?.allowed) return {};
-  // #3043 — a project role's entries were read at one commit; the working tree never applies.
+  // a project role's entries were read at one commit; the working tree never applies.
   if (profile?.pinnedProjectMcp) return { ...profile.pinnedProjectMcp.servers };
   const file = join(config.cwd, PROJECT_MCP_FILE);
   if (!existsSync(file)) return {};
@@ -146,13 +145,13 @@ export function resolveClaudeHostSkills(
   provider: string = "claude",
 ): ResolvedAsset[] {
   if (!hostSourcesFor(config).skills) return [];
-  // #2513 — keyed by provider id so a dedicatedHome claude-family provider (claude-b)
+  // keyed by provider id so a dedicatedHome claude-family provider (claude-b)
   // resolves host skills from ITS OWN source home, never ~/.claude's.
   return linkedSkillAssets(join(providerSourceHome(provider), "skills"), claudeHome, reservedNames);
 }
 
 export interface ResolvedSourceShadow {
-  source: "host" | "project" | "agent-relay";
+  source: import("@humwick/sdk").ProfileSourceKind;
   capability: "mcp" | "hooks" | "skills" | "plugins";
   name: string;
 }
@@ -328,7 +327,7 @@ function materializeAsset(asset: ResolvedAsset): boolean {
   return existsSync(asset.dir);
 }
 
-// #554 (Claude) — each provisioned skill lands at <claudeHome>/skills/<name> so it's
+// (Claude) — each provisioned skill lands at <claudeHome>/skills/<name> so it's
 // auto-discovered under the launch's `--setting-sources "user"` scope (host skills
 // never bleed). Inline files are written there; a pre-existing dir is symlinked in.
 export function resolveClaudeProvisionedSkills(claudeHome: string, config: RunnerSpawnConfig): ResolvedAsset[] {
@@ -338,7 +337,7 @@ export function resolveClaudeProvisionedSkills(claudeHome: string, config: Runne
   for (const skill of skills) {
     const dir = join(skillsRoot, assetDirName(skill.name));
     if (skill.files?.length) {
-      resolved.push({ name: skill.name, dir, source: { kind: "files", files: providerIntegrationFiles(skill.name, skill.files, runnerMcpGeneration(config.env)) } });
+      resolved.push({ name: skill.name, dir, source: { kind: "files", files: providerIntegrationFiles(skill.name, skill.files) } });
       continue;
     }
     if (skill.dir) {
@@ -349,7 +348,7 @@ export function resolveClaudeProvisionedSkills(claudeHome: string, config: Runne
   return resolved;
 }
 
-// #556 (Claude) — each provisioned plugin resolves to a --plugin-dir. Inline plugins
+// (Claude) — each provisioned plugin resolves to a --plugin-dir. Inline plugins
 // materialize under <claudeHome>/relay-provisioned-plugins/<name>; declared dirs are
 // used in place. The resolved `dir` is appended to the launch's --plugin-dir set.
 export function resolveClaudeProvisionedPlugins(claudeHome: string, config: RunnerSpawnConfig): ResolvedAsset[] {
@@ -358,7 +357,7 @@ export function resolveClaudeProvisionedPlugins(claudeHome: string, config: Runn
   const resolved: ResolvedAsset[] = [];
   for (const plugin of plugins) {
     if (plugin.files?.length) {
-      resolved.push({ name: plugin.name, dir: join(parent, assetDirName(plugin.name)), source: { kind: "files", files: providerIntegrationFiles(plugin.name, plugin.files, runnerMcpGeneration(config.env)) } });
+      resolved.push({ name: plugin.name, dir: join(parent, assetDirName(plugin.name)), source: { kind: "files", files: providerIntegrationFiles(plugin.name, plugin.files) } });
       continue;
     }
     if (plugin.dir) {
@@ -369,18 +368,18 @@ export function resolveClaudeProvisionedPlugins(claudeHome: string, config: Runn
   return resolved;
 }
 
-// #554 (Codex) — each provisioned skill resolves to a dir for `-c skills.config`.
+// (Codex) — each provisioned skill resolves to a dir for `-c skills.config`.
 // Inline skills materialize under <codexHome>/relay-provisioned-skills/<name>; declared
 // dirs are used in place. Codex requires a SKILL.md at the dir root to register it, so
 // inline sets without one and dirs missing it are dropped at resolution time.
-export function resolveCodexProvisionedSkills(codexHome: string, config: RunnerSpawnConfig): ResolvedAsset[] {
+export function resolveProvisionedSkillPaths(home: string, config: RunnerSpawnConfig): ResolvedAsset[] {
   const { skills } = profileProvisioning(config);
-  const parent = join(codexHome, "relay-provisioned-skills");
+  const parent = join(home, "relay-provisioned-skills");
   const resolved: ResolvedAsset[] = [];
   for (const skill of skills) {
     if (skill.files?.length) {
       if (!hasRootSkillManifest(skill.files)) continue;
-      resolved.push({ name: skill.name, dir: join(parent, assetDirName(skill.name)), source: { kind: "files", files: providerIntegrationFiles(skill.name, skill.files, runnerMcpGeneration(config.env)) } });
+      resolved.push({ name: skill.name, dir: join(parent, assetDirName(skill.name)), source: { kind: "files", files: providerIntegrationFiles(skill.name, skill.files) } });
       continue;
     }
     if (skill.dir) {
@@ -391,6 +390,8 @@ export function resolveCodexProvisionedSkills(codexHome: string, config: RunnerS
   return resolved;
 }
 
+export { resolveProvisionedSkillPaths as resolveCodexProvisionedSkills };
+
 export function resolveProvisionedHooks(home: string, config: RunnerSpawnConfig): ResolvedHookAsset[] {
   const { hooks } = profileProvisioning(config);
   const parent = join(home, "relay-provisioned-hooks");
@@ -464,7 +465,7 @@ export function codexHookTrustEntries(codexHome: string, hooks: ProvisioningHook
   return hookTrustEntries([...new Set([codexHome, realpathOr(codexHome)])].map((home) => join(home, "hooks.json")), hooks);
 }
 
-// #3025 — Codex also reads TOML hooks and their trust state from the `-c` session-flags layer,
+// Codex also reads TOML hooks and their trust state from the `-c` session-flags layer,
 // keyed on this synthetic source, so a launch can carry hooks while keeping any CODEX_HOME.
 const CODEX_SESSION_FLAGS_SOURCE = "/<session-flags>/config.toml";
 
@@ -577,7 +578,7 @@ function canonicalJson(value: unknown): unknown {
   return value;
 }
 
-// #1096 — write relay-owned settings into an ISOLATED Claude managed home's `settings.json`
+// write relay-owned settings into an ISOLATED Claude managed home's `settings.json`
 // (the DOCUMENTED hook source Claude honors under `--setting-sources "user"` or the default,
 // unlike the inline `--settings` CLI flag). The managed home is relay-owned and freshly keyed
 // per spawn, so an unconditional write is safe (profile-home seeds only `.claude.json`/`CLAUDE.md`,
@@ -601,7 +602,7 @@ export function writeClaudeSettingsJson(claudeHome: string, settings: Record<str
   }
 }
 
-// T3182 — merge a permissions.deny entry into a managed Claude settings payload WITHOUT
+// merge a permissions.deny entry into a managed Claude settings payload WITHOUT
 // clobbering permissions the payload already carries (deny lists union, everything else passes
 // through). Pure — the caller composes and writes.
 export function mergeClaudeSettingsDeny(settings: Record<string, unknown>, deny: string[]): Record<string, unknown> {
@@ -622,22 +623,18 @@ export function mergeClaudeSettingsAllow(settings: Record<string, unknown>, allo
 }
 
 export const CLAUDE_GUARDED_RELAY_TOOLS = [
-  "mcp__agent-relay__relay_send_message",
-  "mcp__agent-relay__relay_reply",
-  "mcp__agent-relay__relay_task_set_status",
-  "mcp__agent-relay__relay_task_comment",
-  "mcp__agent-relay__relay_task_deliver",
+  "mcp__humwick__humwick_send_message",
+  "mcp__humwick__humwick_reply",
+  "mcp__humwick__humwick_task_set_status",
+  "mcp__humwick__humwick_task_comment",
+  "mcp__humwick__humwick_task_deliver",
 ];
 
-function guardedRelayTools(generation: ToolGeneration): string[] {
-  return CLAUDE_GUARDED_RELAY_TOOLS.map(name => `mcp__${mcpServerInfo(generation).name}__${wireToolName(name.split("__").at(-1)!, generation)}`);
-}
-
-export function claudeGuardedRelaySettings(approvalMode: string | undefined, generation: ToolGeneration = "relay"): Record<string, unknown> {
-  return approvalMode === "guarded" ? { permissions: { allow: guardedRelayTools(generation) } } : {};
+export function claudeGuardedRelaySettings(approvalMode: string | undefined): Record<string, unknown> {
+  return approvalMode === "guarded" ? { permissions: { allow: [...CLAUDE_GUARDED_RELAY_TOOLS] } } : {};
 }
 
-// #3388 — Claude's project scan loads CLAUDE.md, CLAUDE.local.md, .claude/CLAUDE.md and .claude/rules/**
+// Claude's project scan loads CLAUDE.md, CLAUDE.local.md, .claude/CLAUDE.md and .claude/rules/**
 // from EVERY ancestor of the cwd, so host files above the repo (~/.claude/CLAUDE.md, ~/CLAUDE.md,
 // ~/projects/CLAUDE.md) reach an agent despite the isolated CLAUDE_CONFIG_DIR. Host instructions
 // `ignore` excludes them through the supported `claudeMdExcludes` setting. Rule: the repo root
@@ -687,9 +684,9 @@ export function mergeClaudeRelayPermissions(settings: Record<string, unknown>, r
   return mergeClaudeSettingsAllow(settings, allow);
 }
 
-export function withManagedClaudePermissions(settings: Record<string, unknown>, approvalMode: string | undefined, generation: ToolGeneration = "relay"): Record<string, unknown> {
-  const guarded = approvalMode === "guarded" ? mergeClaudeSettingsAllow(settings, guardedRelayTools(generation)) : settings;
-  return projectClaudePermissionRules(mergeClaudeSettingsDeny({ ...guarded, ...claudeBypassPermissionSettings(approvalMode), idleCompaction: false }, ["SendFeedback"]), generation);
+export function withManagedClaudePermissions(settings: Record<string, unknown>, approvalMode: string | undefined): Record<string, unknown> {
+  const guarded = approvalMode === "guarded" ? mergeClaudeSettingsAllow(settings, [...CLAUDE_GUARDED_RELAY_TOOLS]) : settings;
+  return projectClaudePermissionRules(mergeClaudeSettingsDeny({ ...guarded, ...claudeBypassPermissionSettings(approvalMode), idleCompaction: false }, ["SendFeedback"]));
 }
 
 // Write the resolved assets to disk; returns the dirs that materialized successfully,