diff --git a/cli/azd/.vscode/cspell.yaml b/cli/azd/.vscode/cspell.yaml
index 386ee69820e..ac590e59491 100644
--- a/cli/azd/.vscode/cspell.yaml
+++ b/cli/azd/.vscode/cspell.yaml
@@ -383,6 +383,12 @@ overrides:
       - unvalidated
       - venvs
       - workdir
+  - filename: pkg/tools/language/python_executor.go
+    words:
+      - venvs
+  - filename: extensions/azure.ai.agents/internal/cmd/init_locations.go
+    words:
+      - swedencentral
   - filename: docs/code-coverage-guide.md
     words:
       - covdata
diff --git a/cli/azd/pkg/ext/hooks_config_test.go b/cli/azd/pkg/ext/hooks_config_test.go
index 69829b0d075..cc32b41e18d 100644
--- a/cli/azd/pkg/ext/hooks_config_test.go
+++ b/cli/azd/pkg/ext/hooks_config_test.go
@@ -246,6 +246,319 @@ predeploy:
 				"script4.sh", hooks["predeploy"][0].Run,
 			)
 		})
+
+	t.Run("hook with config block", func(t *testing.T) {
+		const doc = `
+postprovision:
+  run: ./hooks/seed-database.cs
+  kind: dotnet
+  config:
+    configuration: Release
+    framework: net10.0
+`
+
+		var hooks HooksConfig
+		err := yaml.Unmarshal([]byte(doc), &hooks)
+		require.NoError(t, err)
+
+		require.Len(t, hooks["postprovision"], 1)
+		hook := hooks["postprovision"][0]
+		assert.Equal(t, "./hooks/seed-database.cs", hook.Run)
+		assert.Equal(t,
+			language.HookKindDotNet, hook.Kind,
+		)
+		require.NotNil(t, hook.Config)
+		assert.Equal(t, "Release", hook.Config["configuration"])
+		assert.Equal(t, "net10.0", hook.Config["framework"])
+	})
+
+	t.Run("multiple hooks with different configs",
+		func(t *testing.T) {
+			const doc = `
+postprovision:
+  - run: ./hooks/seed-database.cs
+    kind: dotnet
+    config:
+      configuration: Release
+  - run: ./hooks/setup.py
+    kind: python
+    config:
+      virtualEnvName: .venv
+`
+
+			var hooks HooksConfig
+			err := yaml.Unmarshal([]byte(doc), &hooks)
+			require.NoError(t, err)
+
+			require.Len(t, hooks["postprovision"], 2)
+
+			dotnetHook := hooks["postprovision"][0]
+			assert.Equal(t,
+				"./hooks/seed-database.cs", dotnetHook.Run,
+			)
+			require.NotNil(t, dotnetHook.Config)
+			assert.Equal(t,
+				"Release",
+				dotnetHook.Config["configuration"],
+			)
+
+			pythonHook := hooks["postprovision"][1]
+			assert.Equal(t,
+				"./hooks/setup.py", pythonHook.Run,
+			)
+			require.NotNil(t, pythonHook.Config)
+			assert.Equal(t,
+				".venv",
+				pythonHook.Config["virtualEnvName"],
+			)
+		})
+
+	t.Run("nested config maps", func(t *testing.T) {
+		const doc = `
+postprovision:
+  run: ./hooks/setup.py
+  kind: python
+  config:
+    database:
+      host: localhost
+      port: 5432
+    logging:
+      level: debug
+`
+
+		var hooks HooksConfig
+		err := yaml.Unmarshal([]byte(doc), &hooks)
+		require.NoError(t, err)
+
+		require.Len(t, hooks["postprovision"], 1)
+		hook := hooks["postprovision"][0]
+		require.NotNil(t, hook.Config)
+
+		db, ok := hook.Config["database"].(map[string]any)
+		require.True(t, ok,
+			"database should be map[string]any",
+		)
+		assert.Equal(t, "localhost", db["host"])
+		assert.Equal(t, 5432, db["port"])
+
+		logging, ok :=
+			hook.Config["logging"].(map[string]any)
+		require.True(t, ok,
+			"logging should be map[string]any",
+		)
+		assert.Equal(t, "debug", logging["level"])
+	})
+
+	t.Run("config with list values", func(t *testing.T) {
+		const doc = `
+postprovision:
+  run: ./hooks/setup.sh
+  config:
+    paths:
+      - ./src
+      - ./lib
+    flags:
+      - --verbose
+      - --dry-run
+`
+
+		var hooks HooksConfig
+		err := yaml.Unmarshal([]byte(doc), &hooks)
+		require.NoError(t, err)
+
+		require.Len(t, hooks["postprovision"], 1)
+		hook := hooks["postprovision"][0]
+		require.NotNil(t, hook.Config)
+
+		paths, ok := hook.Config["paths"].([]any)
+		require.True(t, ok,
+			"paths should be []any",
+		)
+		require.Len(t, paths, 2)
+		assert.Equal(t, "./src", paths[0])
+		assert.Equal(t, "./lib", paths[1])
+
+		flags, ok := hook.Config["flags"].([]any)
+		require.True(t, ok,
+			"flags should be []any",
+		)
+		require.Len(t, flags, 2)
+		assert.Equal(t, "--verbose", flags[0])
+		assert.Equal(t, "--dry-run", flags[1])
+	})
+
+	t.Run("platform override hooks with config",
+		func(t *testing.T) {
+			const doc = `
+postprovision:
+  run: ./hooks/setup.py
+  kind: python
+  config:
+    virtualEnvName: .venv
+  windows:
+    run: .\hooks\setup.py
+    kind: python
+    config:
+      virtualEnvName: .win-venv
+  posix:
+    run: ./hooks/setup.py
+    kind: python
+    config:
+      virtualEnvName: .posix-venv
+`
+
+			var hooks HooksConfig
+			err := yaml.Unmarshal([]byte(doc), &hooks)
+			require.NoError(t, err)
+
+			require.Len(t, hooks["postprovision"], 1)
+			hook := hooks["postprovision"][0]
+
+			require.NotNil(t, hook.Config)
+			assert.Equal(t,
+				".venv",
+				hook.Config["virtualEnvName"],
+			)
+
+			require.NotNil(t, hook.Windows)
+			require.NotNil(t, hook.Windows.Config)
+			assert.Equal(t,
+				".win-venv",
+				hook.Windows.Config["virtualEnvName"],
+			)
+
+			require.NotNil(t, hook.Posix)
+			require.NotNil(t, hook.Posix.Config)
+			assert.Equal(t,
+				".posix-venv",
+				hook.Posix.Config["virtualEnvName"],
+			)
+		})
+
+	t.Run("config type preservation",
+		func(t *testing.T) {
+			const doc = `
+postprovision:
+  run: ./hooks/setup.sh
+  config:
+    retries: 3
+    verbose: true
+    timeout: 30.5
+    name: my-hook
+`
+
+			var hooks HooksConfig
+			err := yaml.Unmarshal([]byte(doc), &hooks)
+			require.NoError(t, err)
+
+			require.Len(t, hooks["postprovision"], 1)
+			hook := hooks["postprovision"][0]
+			require.NotNil(t, hook.Config)
+
+			assert.IsType(t, 0, hook.Config["retries"])
+			assert.Equal(t, 3, hook.Config["retries"])
+
+			assert.IsType(t,
+				true, hook.Config["verbose"],
+			)
+			assert.Equal(t,
+				true, hook.Config["verbose"],
+			)
+
+			assert.IsType(t,
+				0.0, hook.Config["timeout"],
+			)
+			assert.InDelta(t,
+				30.5, hook.Config["timeout"], 0.001,
+			)
+
+			assert.IsType(t, "", hook.Config["name"])
+			assert.Equal(t,
+				"my-hook", hook.Config["name"],
+			)
+
+			// Roundtrip preserves types.
+			data, err := yaml.Marshal(hooks)
+			require.NoError(t, err)
+
+			var got HooksConfig
+			err = yaml.Unmarshal(data, &got)
+			require.NoError(t, err)
+
+			rtHook := got["postprovision"][0]
+			require.NotNil(t, rtHook.Config)
+			assert.Equal(t, hook.Config, rtHook.Config)
+		})
+
+	t.Run("empty config block", func(t *testing.T) {
+		const doc = `
+postprovision:
+  run: ./hooks/setup.sh
+  config: {}
+`
+
+		var hooks HooksConfig
+		err := yaml.Unmarshal([]byte(doc), &hooks)
+		require.NoError(t, err)
+
+		require.Len(t, hooks["postprovision"], 1)
+		hook := hooks["postprovision"][0]
+
+		require.NotNil(t, hook.Config)
+		assert.Empty(t, hook.Config)
+
+		// Marshal omits empty config via omitempty tag.
+		data, err := yaml.Marshal(hooks)
+		require.NoError(t, err)
+		assert.NotContains(t, string(data), "config")
+	})
+
+	t.Run("config in list-format hooks",
+		func(t *testing.T) {
+			const doc = `
+postprovision:
+  - run: ./hooks/first.py
+    kind: python
+    config:
+      virtualEnvName: .venv
+  - run: ./hooks/second.ts
+    kind: ts
+    config:
+      packageManager: pnpm
+`
+
+			var hooks HooksConfig
+			err := yaml.Unmarshal([]byte(doc), &hooks)
+			require.NoError(t, err)
+
+			require.Len(t, hooks["postprovision"], 2)
+
+			first := hooks["postprovision"][0]
+			assert.Equal(t,
+				"./hooks/first.py", first.Run,
+			)
+			assert.Equal(t,
+				language.HookKindPython, first.Kind,
+			)
+			require.NotNil(t, first.Config)
+			assert.Equal(t,
+				".venv",
+				first.Config["virtualEnvName"],
+			)
+
+			second := hooks["postprovision"][1]
+			assert.Equal(t,
+				"./hooks/second.ts", second.Run,
+			)
+			assert.Equal(t,
+				language.HookKindTypeScript, second.Kind,
+			)
+			require.NotNil(t, second.Config)
+			assert.Equal(t,
+				"pnpm",
+				second.Config["packageManager"],
+			)
+		})
 }
 
 func TestHooksConfig_MarshalYAML(t *testing.T) {
@@ -364,6 +677,42 @@ preprovision:
 				got["preprovision"][1].Run,
 			)
 		})
+
+	t.Run("roundtrip with config block", func(t *testing.T) {
+		hooks := HooksConfig{
+			"postprovision": {
+				{
+					Run:  "./hooks/seed.cs",
+					Kind: language.HookKindDotNet,
+					Config: map[string]any{
+						"configuration": "Release",
+						"framework":     "net10.0",
+					},
+				},
+			},
+		}
+
+		data, err := yaml.Marshal(hooks)
+		require.NoError(t, err)
+
+		var got HooksConfig
+		err = yaml.Unmarshal(data, &got)
+		require.NoError(t, err)
+
+		require.Len(t, got["postprovision"], 1)
+		hook := got["postprovision"][0]
+		assert.Equal(t, "./hooks/seed.cs", hook.Run)
+		assert.Equal(t,
+			language.HookKindDotNet, hook.Kind,
+		)
+		require.NotNil(t, hook.Config)
+		assert.Equal(t,
+			"Release", hook.Config["configuration"],
+		)
+		assert.Equal(t,
+			"net10.0", hook.Config["framework"],
+		)
+	})
 }
 
 func TestHooksConfig_RoundTrip(t *testing.T) {
diff --git a/cli/azd/pkg/ext/hooks_runner.go b/cli/azd/pkg/ext/hooks_runner.go
index 9e8c1066b41..c100c89e32d 100644
--- a/cli/azd/pkg/ext/hooks_runner.go
+++ b/cli/azd/pkg/ext/hooks_runner.go
@@ -178,6 +178,7 @@ func (h *HooksRunner) execHook(
 		BoundaryDir:  boundaryDir,
 		InlineScript: hookConfig.inlineScript,
 		HookName:     hookConfig.Name,
+		Config:       hookConfig.Config,
 	}
 
 	// Merge caller-provided overrides (e.g. forced interactive from 'azd hooks run').
diff --git a/cli/azd/pkg/ext/hooks_runner_test.go b/cli/azd/pkg/ext/hooks_runner_test.go
index ff3625ca3c3..510c9c10144 100644
--- a/cli/azd/pkg/ext/hooks_runner_test.go
+++ b/cli/azd/pkg/ext/hooks_runner_test.go
@@ -14,6 +14,7 @@ import (
 	"github.com/azure/azure-dev/cli/azd/pkg/environment"
 	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/osutil"
+	"github.com/azure/azure-dev/cli/azd/pkg/tools"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools/language"
 	"github.com/azure/azure-dev/cli/azd/test/mocks"
 	"github.com/azure/azure-dev/cli/azd/test/mocks/mockenv"
@@ -1049,3 +1050,193 @@ func Test_ExecHook_DirRunResolution(t *testing.T) {
 		)
 	})
 }
+
+// configCaptureExecutor is a test-only [tools.HookExecutor] that
+// captures the [tools.ExecutionContext] passed to Execute so tests
+// can assert on it.
+type configCaptureExecutor struct {
+	onExecute func(tools.ExecutionContext)
+}
+
+func (e *configCaptureExecutor) Prepare(
+	_ context.Context, _ string, _ tools.ExecutionContext,
+) error {
+	return nil
+}
+
+func (e *configCaptureExecutor) Execute(
+	_ context.Context, _ string, execCtx tools.ExecutionContext,
+) (exec.RunResult, error) {
+	if e.onExecute != nil {
+		e.onExecute(execCtx)
+	}
+	return exec.NewRunResult(0, "", ""), nil
+}
+
+func (e *configCaptureExecutor) Cleanup(
+	_ context.Context,
+) error {
+	return nil
+}
+
+// Test_ExecHook_ConfigThreading verifies that HookConfig.Config is
+// threaded through to ExecutionContext.Config when executing a hook.
+func Test_ExecHook_ConfigThreading(t *testing.T) {
+	t.Run("ConfigPassedToExecutor", func(t *testing.T) {
+		cwd := t.TempDir()
+		ostest.Chdir(t, cwd)
+
+		env := environment.NewWithValues(
+			"test", map[string]string{},
+		)
+
+		// Create a script file so validate() resolves it.
+		require.NoError(t, os.MkdirAll(
+			filepath.Join(cwd, "scripts"),
+			osutil.PermissionDirectory,
+		))
+		require.NoError(t, os.WriteFile(
+			filepath.Join(cwd, "scripts", "hook.sh"),
+			nil, osutil.PermissionExecutableFile,
+		))
+
+		expectedConfig := map[string]any{
+			"key1":   "value1",
+			"number": 42,
+			"nested": map[string]any{"a": "b"},
+		}
+
+		hooksMap := map[string][]*HookConfig{
+			"predeploy": {
+				{
+					Name:   "predeploy",
+					Shell:  string(language.HookKindBash),
+					Run:    "scripts/hook.sh",
+					Config: expectedConfig,
+				},
+			},
+		}
+
+		envManager := &mockenv.MockEnvManager{}
+		envManager.On(
+			"Reload", mock.Anything, env,
+		).Return(nil)
+
+		var capturedCtx tools.ExecutionContext
+		mockContext := mocks.NewMockContext(
+			context.Background(),
+		)
+
+		// Register a capture executor instead of the real
+		// bash executor so we can inspect ExecutionContext.
+		mockContext.Container.MustRegisterNamedTransient(
+			string(language.HookKindBash),
+			func() tools.HookExecutor {
+				return &configCaptureExecutor{
+					onExecute: func(
+						ctx tools.ExecutionContext,
+					) {
+						capturedCtx = ctx
+					},
+				}
+			},
+		)
+
+		hooksManager := NewHooksManager(
+			HooksManagerOptions{Cwd: cwd}, mockContext.CommandRunner,
+		)
+		runner := NewHooksRunner(
+			hooksManager,
+			mockContext.CommandRunner,
+			envManager,
+			mockContext.Console,
+			cwd,
+			hooksMap,
+			env,
+			mockContext.Container,
+		)
+
+		err := runner.RunHooks(
+			*mockContext.Context, HookTypePre, nil,
+			"deploy",
+		)
+		require.NoError(t, err)
+
+		require.Equal(t, expectedConfig, capturedCtx.Config)
+		require.Equal(t, "predeploy", capturedCtx.HookName)
+	})
+
+	t.Run("NilConfigWhenNotSet", func(t *testing.T) {
+		cwd := t.TempDir()
+		ostest.Chdir(t, cwd)
+
+		env := environment.NewWithValues(
+			"test", map[string]string{},
+		)
+
+		require.NoError(t, os.MkdirAll(
+			filepath.Join(cwd, "scripts"),
+			osutil.PermissionDirectory,
+		))
+		require.NoError(t, os.WriteFile(
+			filepath.Join(cwd, "scripts", "hook.sh"),
+			nil, osutil.PermissionExecutableFile,
+		))
+
+		hooksMap := map[string][]*HookConfig{
+			"predeploy": {
+				{
+					Name:  "predeploy",
+					Shell: string(language.HookKindBash),
+					Run:   "scripts/hook.sh",
+					// No Config set.
+				},
+			},
+		}
+
+		envManager := &mockenv.MockEnvManager{}
+		envManager.On(
+			"Reload", mock.Anything, env,
+		).Return(nil)
+
+		var capturedCtx tools.ExecutionContext
+		mockContext := mocks.NewMockContext(
+			context.Background(),
+		)
+
+		mockContext.Container.MustRegisterNamedTransient(
+			string(language.HookKindBash),
+			func() tools.HookExecutor {
+				return &configCaptureExecutor{
+					onExecute: func(
+						ctx tools.ExecutionContext,
+					) {
+						capturedCtx = ctx
+					},
+				}
+			},
+		)
+
+		hooksManager := NewHooksManager(
+			HooksManagerOptions{Cwd: cwd}, mockContext.CommandRunner,
+		)
+		runner := NewHooksRunner(
+			hooksManager,
+			mockContext.CommandRunner,
+			envManager,
+			mockContext.Console,
+			cwd,
+			hooksMap,
+			env,
+			mockContext.Container,
+		)
+
+		err := runner.RunHooks(
+			*mockContext.Context, HookTypePre, nil,
+			"deploy",
+		)
+		require.NoError(t, err)
+
+		require.Nil(t, capturedCtx.Config)
+	})
+}
diff --git a/cli/azd/pkg/ext/models.go b/cli/azd/pkg/ext/models.go
index c067020f156..ad6ba9e58aa 100644
--- a/cli/azd/pkg/ext/models.go
+++ b/cli/azd/pkg/ext/models.go
@@ -6,6 +6,7 @@ package ext
 import (
 	"crypto/sha256"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"maps"
@@ -132,6 +133,10 @@ type HookConfig struct {
 	// Environment variables in this list are added to the hook script and if the value is a akvs:// reference
 	// it will be resolved to the secret value
 	Secrets map[string]string `yaml:"secrets,omitempty"`
+	// Config is an optional property bag of executor-specific settings,
+	// discriminated by Kind. Each executor may unmarshal this into a
+	// strongly-typed struct for its own configuration needs.
+	Config map[string]any `yaml:"config,omitempty"`
 }
 
 // validate normalizes and validates the hook configuration. It resolves
@@ -585,6 +590,20 @@ func appendHookConfigSignature(builder *strings.Builder, hookConfig *HookConfig)
 		builder.WriteByte('\x00')
 	}
 
+	// Config is a map[string]any — use JSON for deterministic key ordering.
+	if len(hookConfig.Config) > 0 {
+		configJSON, err := json.Marshal(hookConfig.Config)
+		// Config values originate from azure.yaml, which produces
+		// JSON-compatible types (strings, numbers, bools, maps, slices).
+		// Marshal errors are theoretically possible but not in practice,
+		// so we skip the config contribution rather than failing the
+		// signature calculation.
+		if err == nil {
+			builder.Write(configJSON)
+		}
+		builder.WriteByte('\x00')
+	}
+
 	appendHookConfigSignature(builder, hookConfig.Windows)
 	appendHookConfigSignature(builder, hookConfig.Posix)
 }
diff --git a/cli/azd/pkg/ext/models_test.go b/cli/azd/pkg/ext/models_test.go
index 378e47a52cb..95258e2ce58 100644
--- a/cli/azd/pkg/ext/models_test.go
+++ b/cli/azd/pkg/ext/models_test.go
@@ -480,7 +480,7 @@ func TestHookConfig_ValidateDirRunResolution(t *testing.T) {
 				Run:  "main.py",
 				Dir:  filepath.Join("hooks", "preprovision"),
 			},
-			// Put file in dir but also at root — the
+			// Put file in dir but also at root ΓÇö the
 			// absolute path case is tested next; here we
 			// verify the dir path is used.
 			createFiles: []string{
@@ -753,7 +753,7 @@ func TestHookConfig_ResolvedPaths(t *testing.T) {
 func TestHookConfig_ValidatePathTraversal(t *testing.T) {
 	cwd := t.TempDir()
 
-	// File-based hook with Dir escaping project root — must fail.
+	// File-based hook with Dir escaping project root ΓÇö must fail.
 	escapeDir := filepath.Join(cwd, "..", "..", "escape")
 	require.NoError(t, os.MkdirAll(escapeDir, 0o755))
 	scriptPath := filepath.Join(escapeDir, "evil.sh")
@@ -893,7 +893,7 @@ func TestHookConfig_ServiceHookEscapesProjectRoot(
 	)
 	require.NoError(t, os.MkdirAll(serviceCwd, 0o755))
 
-	// Script file outside the project root — the
+	// Script file outside the project root ΓÇö the
 	// boundary check must reject this.
 	outsideDir := t.TempDir()
 	scriptPath := filepath.Join(outsideDir, "evil.sh")
@@ -1326,3 +1326,170 @@ func TestHookConfig_DirRunKindInference(t *testing.T) {
 		})
 	}
 }
+
+func TestHookConfig_ConfigField(t *testing.T) {
+	tests := []struct {
+		name           string
+		yamlInput      string
+		expectedConfig map[string]any
+	}{
+		{
+			name: "StringValues",
+			yamlInput: "run: hooks/seed.py\nkind: python\nconfig:\n" +
+				"  framework: net10.0\n  configuration: Release\n",
+			expectedConfig: map[string]any{
+				"framework":     "net10.0",
+				"configuration": "Release",
+			},
+		},
+		{
+			name: "NumericValue",
+			yamlInput: "run: hooks/seed.py\nkind: python\nconfig:\n" +
+				"  retries: 3\n  timeout: 30.5\n",
+			expectedConfig: map[string]any{
+				"retries": 3,
+				"timeout": 30.5,
+			},
+		},
+		{
+			name: "BooleanValue",
+			yamlInput: "run: hooks/seed.py\nkind: python\nconfig:\n" +
+				"  verbose: true\n",
+			expectedConfig: map[string]any{
+				"verbose": true,
+			},
+		},
+		{
+			name: "NestedMap",
+			yamlInput: "run: hooks/seed.py\nkind: python\nconfig:\n" +
+				"  database:\n    host: localhost\n    port: 5432\n",
+			expectedConfig: map[string]any{
+				"database": map[string]any{
+					"host": "localhost",
+					"port": 5432,
+				},
+			},
+		},
+		{
+			name: "ListValue",
+			yamlInput: "run: hooks/seed.py\nkind: python\nconfig:\n" +
+				"  args:\n    - --verbose\n    - --dry-run\n",
+			expectedConfig: map[string]any{
+				"args": []any{"--verbose", "--dry-run"},
+			},
+		},
+		{
+			name:           "NoConfig",
+			yamlInput:      "run: hooks/seed.py\nkind: python\n",
+			expectedConfig: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var config HookConfig
+			err := yaml.Unmarshal([]byte(tt.yamlInput), &config)
+			require.NoError(t, err)
+			require.Equal(t, tt.expectedConfig, config.Config)
+		})
+	}
+}
+
+func TestHookConfig_ConfigRoundTrip(t *testing.T) {
+	original := HookConfig{
+		Run:  "hooks/deploy.py",
+		Kind: language.HookKindPython,
+		Config: map[string]any{
+			"framework":     "net10.0",
+			"configuration": "Release",
+			"nested":        map[string]any{"key": "val"},
+		},
+	}
+
+	data, err := yaml.Marshal(&original)
+	require.NoError(t, err)
+
+	var decoded HookConfig
+	err = yaml.Unmarshal(data, &decoded)
+	require.NoError(t, err)
+
+	require.Equal(t, original.Config, decoded.Config)
+	require.Equal(t, original.Kind, decoded.Kind)
+	require.Equal(t, original.Run, decoded.Run)
+}
+
+func TestHookConfig_ConfigOmittedWhenEmpty(t *testing.T) {
+	t.Run("nil config omitted", func(t *testing.T) {
+		config := HookConfig{
+			Run:  "hooks/deploy.py",
+			Kind: language.HookKindPython,
+		}
+
+		data, err := yaml.Marshal(&config)
+		require.NoError(t, err)
+
+		yamlStr := string(data)
+		require.NotContains(t, yamlStr, "config")
+	})
+
+	t.Run("empty map omitted", func(t *testing.T) {
+		config := HookConfig{
+			Run:    "hooks/deploy.py",
+			Kind:   language.HookKindPython,
+			Config: map[string]any{},
+		}
+
+		data, err := yaml.Marshal(&config)
+		require.NoError(t, err)
+
+		yamlStr := string(data)
+		require.NotContains(t, yamlStr, "config")
+	})
+}
+
+func TestHooksConfigSignature_IncludesConfig(t *testing.T) {
+	base := map[string][]*HookConfig{
+		"predeploy": {
+			{
+				Run:  "hooks/deploy.py",
+				Kind: language.HookKindPython,
+			},
+		},
+	}
+	sigWithout := HooksConfigSignature(base)
+	require.NotEmpty(t, sigWithout)
+
+	withConfig := map[string][]*HookConfig{
+		"predeploy": {
+			{
+				Run:  "hooks/deploy.py",
+				Kind: language.HookKindPython,
+				Config: map[string]any{
+					"framework": "net10.0",
+				},
+			},
+		},
+	}
+	sigWith := HooksConfigSignature(withConfig)
+	require.NotEmpty(t, sigWith)
+	require.NotEqual(t, sigWithout, sigWith,
+		"signature should change when Config is added",
+	)
+
+	// Different Config values should produce different signatures.
+	withDifferentConfig := map[string][]*HookConfig{
+		"predeploy": {
+			{
+				Run:  "hooks/deploy.py",
+				Kind: language.HookKindPython,
+				Config: map[string]any{
+					"framework": "net9.0",
+				},
+			},
+		},
+	}
+	sigDiff := HooksConfigSignature(withDifferentConfig)
+	require.NotEqual(t, sigWith, sigDiff,
+		"signature should differ for different Config values",
+	)
+}
diff --git a/cli/azd/pkg/tools/hook_config.go b/cli/azd/pkg/tools/hook_config.go
new file mode 100644
index 00000000000..e24889dab6e
--- /dev/null
+++ b/cli/azd/pkg/tools/hook_config.go
@@ -0,0 +1,31 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package tools
+
+import (
+	"encoding/json"
+	"fmt"
+)
+
+// UnmarshalHookConfig unmarshals the raw config map into a typed struct.
+// Returns a zero-value T if config is nil or empty.
+// Uses JSON re-marshal for deterministic conversion with proper type checking.
+func UnmarshalHookConfig[T any](config map[string]any) (T, error) {
+	var result T
+
+	if len(config) == 0 {
+		return result, nil
+	}
+
+	data, err := json.Marshal(config)
+	if err != nil {
+		return result, fmt.Errorf("marshalling hook config to JSON: %w", err)
+	}
+
+	if err := json.Unmarshal(data, &result); err != nil {
+		return result, fmt.Errorf("unmarshalling hook config: %w", err)
+	}
+
+	return result, nil
+}
diff --git a/cli/azd/pkg/tools/hook_config_test.go b/cli/azd/pkg/tools/hook_config_test.go
new file mode 100644
index 00000000000..2ceb31d405e
--- /dev/null
+++ b/cli/azd/pkg/tools/hook_config_test.go
@@ -0,0 +1,144 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the MIT License.
+
+package tools
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+type testNodeConfig struct {
+	PackageManager string `json:"packageManager"`
+}
+
+type testPythonConfig struct {
+	VirtualEnvName string `json:"virtualEnvName"`
+}
+
+type testDotnetConfig struct {
+	Configuration string `json:"configuration"`
+	Framework     string `json:"framework"`
+}
+
+type testNestedConfig struct {
+	Name    string `json:"name"`
+	Count   int    `json:"count"`
+	Verbose bool   `json:"verbose"`
+}
+
+func TestUnmarshalHookConfig(t *testing.T) {
+	tests := []struct {
+		name string
+		run  func(t *testing.T)
+	}{
+		{
+			name: "NilConfig",
+			run: func(t *testing.T) {
+				result, err := UnmarshalHookConfig[testNodeConfig](nil)
+				require.NoError(t, err)
+				require.Equal(t, testNodeConfig{}, result)
+			},
+		},
+		{
+			name: "EmptyConfig",
+			run: func(t *testing.T) {
+				result, err := UnmarshalHookConfig[testNodeConfig](map[string]any{})
+				require.NoError(t, err)
+				require.Equal(t, testNodeConfig{}, result)
+			},
+		},
+		{
+			name: "ValidStringField",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"packageManager": "pnpm",
+				}
+				result, err := UnmarshalHookConfig[testNodeConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, "pnpm", result.PackageManager)
+			},
+		},
+		{
+			name: "ValidPythonConfig",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"virtualEnvName": ".myenv",
+				}
+				result, err := UnmarshalHookConfig[testPythonConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, ".myenv", result.VirtualEnvName)
+			},
+		},
+		{
+			name: "ValidDotnetConfigMultipleFields",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"configuration": "Release",
+					"framework":     "net8.0",
+				}
+				result, err := UnmarshalHookConfig[testDotnetConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, "Release", result.Configuration)
+				require.Equal(t, "net8.0", result.Framework)
+			},
+		},
+		{
+			name: "ValidNestedTypes",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"name":    "test-hook",
+					"count":   42,
+					"verbose": true,
+				}
+				result, err := UnmarshalHookConfig[testNestedConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, "test-hook", result.Name)
+				require.Equal(t, 42, result.Count)
+				require.True(t, result.Verbose)
+			},
+		},
+		{
+			name: "TypeMismatchReturnsError",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"packageManager": 123,
+				}
+				// JSON numbers unmarshal into strings as an error
+				_, err := UnmarshalHookConfig[testNodeConfig](config)
+				require.Error(t, err)
+				require.Contains(t, err.Error(), "unmarshalling hook config")
+			},
+		},
+		{
+			name: "UnknownKeysIgnored",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"packageManager": "npm",
+					"unknownField":   "some-value",
+					"anotherExtra":   42,
+				}
+				result, err := UnmarshalHookConfig[testNodeConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, "npm", result.PackageManager)
+			},
+		},
+		{
+			name: "PartialConfigUsesZeroDefaults",
+			run: func(t *testing.T) {
+				config := map[string]any{
+					"configuration": "Debug",
+				}
+				result, err := UnmarshalHookConfig[testDotnetConfig](config)
+				require.NoError(t, err)
+				require.Equal(t, "Debug", result.Configuration)
+				require.Empty(t, result.Framework)
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, tt.run)
+	}
+}
diff --git a/cli/azd/pkg/tools/language/dotnet_executor.go b/cli/azd/pkg/tools/language/dotnet_executor.go
index cec5cc48379..809a9ef9ef7 100644
--- a/cli/azd/pkg/tools/language/dotnet_executor.go
+++ b/cli/azd/pkg/tools/language/dotnet_executor.go
@@ -35,6 +35,20 @@ var minSingleFileVersion = semver.Version{
 	Major: 10, Minor: 0, Patch: 0,
 }
 
+// dotnetHookConfig holds the typed configuration that users can
+// specify in azure.yaml under a .NET hook's config section.
+type dotnetHookConfig struct {
+	// Configuration is the MSBuild configuration (Debug, Release,
+	// or a custom name). Passed as `-c` to dotnet build and
+	// dotnet run. Empty means use the SDK default (Debug).
+	Configuration string `json:"configuration"`
+
+	// Framework is the target framework moniker (e.g. net8.0,
+	// net10.0). Passed as `--framework` to dotnet run so the
+	// correct TFM is selected in multi-target projects.
+	Framework string `json:"framework"`
+}
+
 // dotnetExecutor implements [tools.HookExecutor] for .NET (C#)
 // scripts. It supports two execution modes:
 //   - Project mode: when a .csproj/.fsproj/.vbproj is discovered
@@ -48,6 +62,9 @@ type dotnetExecutor struct {
 	// projectPath is set by Prepare when a .NET project file is
 	// discovered. Empty means single-file mode.
 	projectPath string
+
+	// config holds parsed hook configuration from azure.yaml.
+	config dotnetHookConfig
 }
 
 // NewDotNetExecutor creates a .NET HookExecutor.
@@ -110,8 +127,18 @@ func (e *dotnetExecutor) Prepare(
 		)
 	}
 
-	// 3a. Project mode: restore and build.
+	// 3. Project mode: parse config, restore, and build.
 	if projCtx != nil {
+		cfg, err := tools.UnmarshalHookConfig[dotnetHookConfig](
+			execCtx.Config,
+		)
+		if err != nil {
+			return fmt.Errorf(
+				"parsing .NET hook config: %w", err,
+			)
+		}
+		e.config = cfg
+
 		if err := e.dotnetCli.Restore(
 			ctx, projCtx.DependencyFile, execCtx.EnvVars,
 		); err != nil {
@@ -122,7 +149,8 @@ func (e *dotnetExecutor) Prepare(
 		}
 
 		if err := e.dotnetCli.Build(
-			ctx, projCtx.DependencyFile, "", "",
+			ctx, projCtx.DependencyFile,
+			e.config.Configuration, "",
 			execCtx.EnvVars,
 		); err != nil {
 			return fmt.Errorf(
@@ -135,7 +163,7 @@ func (e *dotnetExecutor) Prepare(
 		return nil
 	}
 
-	// 3b. Single-file mode: validate SDK version >= 10.
+	// 4. Single-file mode: validate SDK version >= 10.
 	sdkVer, err := e.dotnetCli.SdkVersion(ctx)
 	if err != nil {
 		return fmt.Errorf(
@@ -188,11 +216,22 @@ func (e *dotnetExecutor) Execute(
 	if e.projectPath != "" {
 		// Project mode — skip restore/build since Prepare
 		// already ran them.
-		runArgs = exec.NewRunArgs(
-			"dotnet", "run",
+		args := []string{
+			"run",
 			"--project", e.projectPath,
 			"--no-build",
-		)
+		}
+
+		if e.config.Configuration != "" {
+			args = append(args, "-c", e.config.Configuration)
+		}
+		if e.config.Framework != "" {
+			args = append(
+				args, "--framework", e.config.Framework,
+			)
+		}
+
+		runArgs = exec.NewRunArgs("dotnet", args...)
 	} else {
 		// Single-file mode.
 		runArgs = exec.NewRunArgs(
diff --git a/cli/azd/pkg/tools/language/dotnet_executor_test.go b/cli/azd/pkg/tools/language/dotnet_executor_test.go
index 89fb865df21..a444e645a28 100644
--- a/cli/azd/pkg/tools/language/dotnet_executor_test.go
+++ b/cli/azd/pkg/tools/language/dotnet_executor_test.go
@@ -29,10 +29,11 @@ type mockDotNetTools struct {
 	restoreErr        error
 	buildErr          error
 
-	restoreCalled  bool
-	restoreProject string
-	buildCalled    bool
-	buildProject   string
+	restoreCalled      bool
+	restoreProject     string
+	buildCalled        bool
+	buildProject       string
+	buildConfiguration string
 }
 
 func (m *mockDotNetTools) CheckInstalled(
@@ -59,11 +60,12 @@ func (m *mockDotNetTools) Restore(
 
 func (m *mockDotNetTools) Build(
 	_ context.Context,
-	project string, _ string,
+	project string, configuration string,
 	_ string, _ []string,
 ) error {
 	m.buildCalled = true
 	m.buildProject = project
+	m.buildConfiguration = configuration
 	return m.buildErr
 }
 
@@ -596,3 +598,159 @@ func TestDotNetExecutor_TableDriven(t *testing.T) {
 		})
 	}
 }
+
+// ---------------------------------------------------------------------------
+// Hook config tests — configuration and framework flags
+// ---------------------------------------------------------------------------
+
+func TestDotNetExecutor_HookConfig(t *testing.T) {
+	tests := []struct {
+		name           string
+		config         map[string]any
+		wantBuildCfg   string
+		wantRunHas     []string // substrings expected in run args
+		wantRunMissing []string // substrings that must NOT appear
+	}{
+		{
+			name:         "ConfigurationRelease",
+			config:       map[string]any{"configuration": "Release"},
+			wantBuildCfg: "Release",
+			wantRunHas:   []string{"-c", "Release"},
+		},
+		{
+			name:         "ConfigurationDebug",
+			config:       map[string]any{"configuration": "Debug"},
+			wantBuildCfg: "Debug",
+			wantRunHas:   []string{"-c", "Debug"},
+		},
+		{
+			name:           "FrameworkOnly",
+			config:         map[string]any{"framework": "net10.0"},
+			wantBuildCfg:   "",
+			wantRunHas:     []string{"--framework", "net10.0"},
+			wantRunMissing: []string{"-c"},
+		},
+		{
+			name: "BothConfigAndFramework",
+			config: map[string]any{
+				"configuration": "Release",
+				"framework":     "net8.0",
+			},
+			wantBuildCfg: "Release",
+			wantRunHas: []string{
+				"-c", "Release",
+				"--framework", "net8.0",
+			},
+		},
+		{
+			name:           "NeitherSet",
+			config:         nil,
+			wantBuildCfg:   "",
+			wantRunMissing: []string{"-c", "--framework"},
+		},
+		{
+			name:           "EmptyConfigMap",
+			config:         map[string]any{},
+			wantBuildCfg:   "",
+			wantRunMissing: []string{"-c", "--framework"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			root := t.TempDir()
+			projectDir := filepath.Join(root, "proj")
+			require.NoError(t,
+				os.MkdirAll(projectDir, 0o700),
+			)
+			writeFile(t,
+				filepath.Join(projectDir, "App.csproj"),
+				"<Project />",
+			)
+
+			cli := &mockDotNetTools{}
+			runner := &mockCommandRunner{}
+			e := newDotNetExecutorInternal(runner, cli)
+
+			execCtx := tools.ExecutionContext{
+				BoundaryDir: root,
+				Cwd:         projectDir,
+				Config:      tt.config,
+			}
+			scriptPath := filepath.Join(
+				projectDir, "hook.cs",
+			)
+
+			require.NoError(t,
+				e.Prepare(t.Context(), scriptPath, execCtx),
+			)
+
+			// Verify Build received the configuration.
+			assert.Equal(t, tt.wantBuildCfg,
+				cli.buildConfiguration,
+				"Build configuration mismatch",
+			)
+
+			_, err := e.Execute(
+				t.Context(), scriptPath, execCtx,
+			)
+			require.NoError(t, err)
+
+			// Verify run args contain expected flags.
+			runArgs := runner.lastRunArgs.Args
+			for _, want := range tt.wantRunHas {
+				assert.Contains(t, runArgs, want,
+					"run args should contain %q", want,
+				)
+			}
+
+			// Verify run args do NOT contain excluded flags.
+			for _, absent := range tt.wantRunMissing {
+				assert.NotContains(t, runArgs, absent,
+					"run args should not contain %q",
+					absent,
+				)
+			}
+
+			// Always verify project-mode invariants.
+			assert.Contains(t, runArgs, "--project")
+			assert.Contains(t, runArgs, "--no-build")
+		})
+	}
+}
+
+func TestDotNetExecutor_SingleFileIgnoresConfig(t *testing.T) {
+	dir := t.TempDir()
+	runner := &mockCommandRunner{}
+	cli := &mockDotNetTools{
+		sdkVersionResult: semver.Version{
+			Major: 10, Minor: 0, Patch: 0,
+		},
+	}
+	e := newDotNetExecutorInternal(runner, cli)
+
+	scriptPath := filepath.Join(dir, "hook.cs")
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: dir,
+		Config: map[string]any{
+			"configuration": "Release",
+			"framework":     "net10.0",
+		},
+	}
+
+	require.NoError(t,
+		e.Prepare(t.Context(), scriptPath, execCtx),
+	)
+
+	_, err := e.Execute(
+		t.Context(), scriptPath, execCtx,
+	)
+	require.NoError(t, err)
+
+	// Single-file mode uses "dotnet run <script>" with no
+	// project-specific flags.
+	assert.Equal(t, []string{"run", scriptPath},
+		runner.lastRunArgs.Args,
+		"single-file mode should not add config flags",
+	)
+}
diff --git a/cli/azd/pkg/tools/language/js_executor.go b/cli/azd/pkg/tools/language/js_executor.go
index 2c6d79b88f3..a0195c79b2b 100644
--- a/cli/azd/pkg/tools/language/js_executor.go
+++ b/cli/azd/pkg/tools/language/js_executor.go
@@ -50,7 +50,8 @@ func (e *jsExecutor) Prepare(
 	execCtx tools.ExecutionContext,
 ) error {
 	_, err := prepareNodeProject(
-		ctx, e.nodeCli, scriptPath, execCtx,
+		ctx, e.nodeCli, e.commandRunner,
+		scriptPath, execCtx,
 	)
 	return err
 }
diff --git a/cli/azd/pkg/tools/language/js_executor_test.go b/cli/azd/pkg/tools/language/js_executor_test.go
index 401f8e941fc..25630bd269f 100644
--- a/cli/azd/pkg/tools/language/js_executor_test.go
+++ b/cli/azd/pkg/tools/language/js_executor_test.go
@@ -149,6 +149,59 @@ func TestJsCleanup_NoOp(t *testing.T) {
 	require.NoError(t, e.Cleanup(t.Context()))
 }
 
+func TestJsPrepare_PackageManagerOverride(t *testing.T) {
+	root := t.TempDir()
+	projectDir := filepath.Join(root, "project")
+	require.NoError(t, os.MkdirAll(projectDir, 0o700))
+	writeFile(t,
+		filepath.Join(projectDir, "package.json"),
+		`{"name": "test"}`,
+	)
+
+	mock := &mockNodeTools{}
+	runner := &mockCommandRunner{
+		runResult: exec.NewRunResult(
+			0, "v20.0.0", "",
+		),
+	}
+	e := newJSExecutorInternal(runner, mock)
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: root,
+		Config: map[string]any{
+			"packageManager": "yarn",
+		},
+	}
+	scriptPath := filepath.Join(projectDir, "hook.js")
+
+	err := e.Prepare(t.Context(), scriptPath, execCtx)
+	require.NoError(t, err)
+
+	// Default mock bypassed — config override used yarn.
+	assert.False(t, mock.installCalled)
+	assert.Equal(t, "yarn", runner.lastRunArgs.Cmd)
+}
+
+func TestJsPrepare_InvalidPackageManager(t *testing.T) {
+	e := newJSExecutorInternal(
+		&mockCommandRunner{}, &mockNodeTools{},
+	)
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: t.TempDir(),
+		Config: map[string]any{
+			"packageManager": "bun",
+		},
+	}
+
+	err := e.Prepare(
+		t.Context(), "/any/hook.js", execCtx,
+	)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(),
+		`invalid packageManager config value "bun"`)
+}
+
 // ---------------------------------------------------------------------------
 // Table-driven comprehensive tests
 // ---------------------------------------------------------------------------
diff --git a/cli/azd/pkg/tools/language/node_helpers.go b/cli/azd/pkg/tools/language/node_helpers.go
index 2b44b51eed8..aaafa53fdfe 100644
--- a/cli/azd/pkg/tools/language/node_helpers.go
+++ b/cli/azd/pkg/tools/language/node_helpers.go
@@ -13,6 +13,7 @@ import (
 	"github.com/azure/azure-dev/cli/azd/pkg/errorhandler"
 	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools"
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/node"
 )
 
 // nodeTools abstracts the Node.js CLI operations needed by
@@ -28,20 +29,88 @@ type nodeTools interface {
 	) error
 }
 
+// nodeHookConfig holds the typed configuration for Node.js-
+// based hook executors (JavaScript and TypeScript). Unmarshalled
+// from [tools.ExecutionContext.Config] via
+// [tools.UnmarshalHookConfig].
+type nodeHookConfig struct {
+	// PackageManager overrides the default package manager
+	// (npm) used for dependency installation. Valid values:
+	// "npm", "pnpm", "yarn". When empty, the default CLI
+	// is used.
+	PackageManager string `json:"packageManager"`
+}
+
+// validNodePackageManagers maps user-facing config values to
+// [node.PackageManagerKind] constants. Matches the values
+// accepted by [nodePackageManagerFromConfig].
+var validNodePackageManagers = map[string]node.PackageManagerKind{
+	"npm":  node.PackageManagerNpm,
+	"pnpm": node.PackageManagerPnpm,
+	"yarn": node.PackageManagerYarn,
+}
+
+// nodePackageManagerFromConfig reads and validates the optional
+// "packageManager" override from hook config. Returns empty
+// string when not set. Returns an error for invalid values.
+func nodePackageManagerFromConfig(
+	config map[string]any,
+) (node.PackageManagerKind, error) {
+	cfg, err := tools.UnmarshalHookConfig[nodeHookConfig](
+		config,
+	)
+	if err != nil {
+		return "", fmt.Errorf(
+			"reading node hook config: %w", err,
+		)
+	}
+
+	if cfg.PackageManager == "" {
+		return "", nil
+	}
+
+	pm, ok := validNodePackageManagers[cfg.PackageManager]
+	if !ok {
+		return "", fmt.Errorf(
+			"invalid packageManager config value %q: "+
+				"must be npm, pnpm, or yarn",
+			cfg.PackageManager,
+		)
+	}
+
+	return pm, nil
+}
+
 // prepareNodeProject handles the shared Prepare phase for
 // Node.js-based executors (JavaScript and TypeScript):
 //  1. Verify Node.js is installed.
 //  2. Discover package.json via [DiscoverNodeProject].
 //  3. If found, run the package manager's install command.
 //
-// Returns the project context (may be nil for standalone
-// scripts that have no package.json).
+// When execCtx.Config contains a "packageManager" key, the
+// specified package manager CLI is used instead of the
+// default. Returns the project context (may be nil for
+// standalone scripts that have no package.json).
 func prepareNodeProject(
 	ctx context.Context,
 	nodeCli nodeTools,
+	commandRunner exec.CommandRunner,
 	scriptPath string,
 	execCtx tools.ExecutionContext,
 ) (*ProjectContext, error) {
+	// Check for a packageManager config override. When set,
+	// create a CLI for the specified package manager instead
+	// of using the default (npm) from the IoC container.
+	pm, err := nodePackageManagerFromConfig(execCtx.Config)
+	if err != nil {
+		return nil, err
+	}
+	if pm != "" {
+		nodeCli = node.NewCliWithPackageManager(
+			commandRunner, pm,
+		)
+	}
+
 	// 1. Verify Node.js is installed.
 	if err := nodeCli.CheckInstalled(ctx); err != nil {
 		// If the error already carries rich context (e.g.
diff --git a/cli/azd/pkg/tools/language/node_helpers_test.go b/cli/azd/pkg/tools/language/node_helpers_test.go
index bb44943cfa0..8d3b022cb22 100644
--- a/cli/azd/pkg/tools/language/node_helpers_test.go
+++ b/cli/azd/pkg/tools/language/node_helpers_test.go
@@ -12,7 +12,9 @@ import (
 	"testing"
 
 	"github.com/azure/azure-dev/cli/azd/pkg/errorhandler"
+	"github.com/azure/azure-dev/cli/azd/pkg/exec"
 	"github.com/azure/azure-dev/cli/azd/pkg/tools"
+	"github.com/azure/azure-dev/cli/azd/pkg/tools/node"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -61,7 +63,8 @@ func TestNodePrepare_NodeNotInstalled(t *testing.T) {
 	}
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, "/any/hook.js", execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		"/any/hook.js", execCtx,
 	)
 
 	require.Error(t, err)
@@ -101,7 +104,8 @@ func TestNodePrepare_CheckInstalledSuggestionPassthrough(
 	}
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, "/any/hook.js", execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		"/any/hook.js", execCtx,
 	)
 
 	require.Error(t, err)
@@ -135,7 +139,8 @@ func TestNodePrepare_WithPackageJSON(t *testing.T) {
 	scriptPath := filepath.Join(hooksDir, "deploy.js")
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, scriptPath, execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		scriptPath, execCtx,
 	)
 
 	require.NoError(t, err)
@@ -156,7 +161,8 @@ func TestNodePrepare_NoPackageJSON(t *testing.T) {
 	scriptPath := filepath.Join(dir, "hook.js")
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, scriptPath, execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		scriptPath, execCtx,
 	)
 
 	require.NoError(t, err)
@@ -184,7 +190,8 @@ func TestNodePrepare_InstallFails(t *testing.T) {
 	scriptPath := filepath.Join(projectDir, "hook.js")
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, scriptPath, execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		scriptPath, execCtx,
 	)
 
 	require.Error(t, err)
@@ -212,7 +219,8 @@ func TestNodePrepare_PythonProjectIgnored(t *testing.T) {
 	scriptPath := filepath.Join(projectDir, "hook.js")
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, scriptPath, execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		scriptPath, execCtx,
 	)
 
 	require.NoError(t, err)
@@ -252,7 +260,8 @@ func TestNodePrepare_MixedLanguageFindsPackageJSON(
 	scriptPath := filepath.Join(projectDir, "hook.js")
 
 	projCtx, err := prepareNodeProject(
-		t.Context(), mock, scriptPath, execCtx,
+		t.Context(), mock, &mockCommandRunner{},
+		scriptPath, execCtx,
 	)
 
 	require.NoError(t, err)
@@ -264,6 +273,169 @@ func TestNodePrepare_MixedLanguageFindsPackageJSON(
 	assert.Equal(t, projectDir, mock.installDir)
 }
 
+// ---------------------------------------------------------------------------
+// nodePackageManagerFromConfig tests
+// ---------------------------------------------------------------------------
+
+func TestNodePackageManagerFromConfig(t *testing.T) {
+	tests := []struct {
+		name    string
+		config  map[string]any
+		wantPM  node.PackageManagerKind
+		wantErr string
+	}{
+		{
+			name:   "NilConfig",
+			config: nil,
+			wantPM: "",
+		},
+		{
+			name:   "EmptyConfig",
+			config: map[string]any{},
+			wantPM: "",
+		},
+		{
+			name: "EmptyString",
+			config: map[string]any{
+				"packageManager": "",
+			},
+			wantPM: "",
+		},
+		{
+			name: "Npm",
+			config: map[string]any{
+				"packageManager": "npm",
+			},
+			wantPM: node.PackageManagerNpm,
+		},
+		{
+			name: "Pnpm",
+			config: map[string]any{
+				"packageManager": "pnpm",
+			},
+			wantPM: node.PackageManagerPnpm,
+		},
+		{
+			name: "Yarn",
+			config: map[string]any{
+				"packageManager": "yarn",
+			},
+			wantPM: node.PackageManagerYarn,
+		},
+		{
+			name: "InvalidValue",
+			config: map[string]any{
+				"packageManager": "bun",
+			},
+			wantErr: "invalid packageManager config " +
+				`value "bun"`,
+		},
+		{
+			name: "WrongType",
+			config: map[string]any{
+				"packageManager": 123,
+			},
+			wantErr: "reading node hook config",
+		},
+		{
+			name: "UnrelatedKeysIgnored",
+			config: map[string]any{
+				"other": "value",
+			},
+			wantPM: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			pm, err := nodePackageManagerFromConfig(
+				tt.config,
+			)
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t,
+					err.Error(), tt.wantErr,
+				)
+				return
+			}
+			require.NoError(t, err)
+			assert.Equal(t, tt.wantPM, pm)
+		})
+	}
+}
+
+// ---------------------------------------------------------------------------
+// prepareNodeProject with config override tests
+// ---------------------------------------------------------------------------
+
+func TestNodePrepare_PackageManagerOverride(
+	t *testing.T,
+) {
+	root := t.TempDir()
+	projectDir := filepath.Join(root, "project")
+	require.NoError(t, os.MkdirAll(projectDir, 0o700))
+	writeFile(t,
+		filepath.Join(projectDir, "package.json"),
+		`{"name": "test"}`,
+	)
+
+	defaultMock := &mockNodeTools{}
+	runner := &mockCommandRunner{
+		runResult: exec.NewRunResult(
+			0, "v20.0.0", "",
+		),
+	}
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: root,
+		Config: map[string]any{
+			"packageManager": "pnpm",
+		},
+	}
+	scriptPath := filepath.Join(projectDir, "hook.js")
+
+	projCtx, err := prepareNodeProject(
+		t.Context(), defaultMock, runner,
+		scriptPath, execCtx,
+	)
+
+	require.NoError(t, err)
+	require.NotNil(t, projCtx)
+	assert.Equal(t, projectDir, projCtx.ProjectDir)
+
+	// Default mock should not have been used — config
+	// override replaced it with a real pnpm CLI.
+	assert.False(t, defaultMock.installCalled,
+		"default CLI should be replaced by config "+
+			"override")
+
+	// Last command should be pnpm install.
+	assert.Equal(t, "pnpm", runner.lastRunArgs.Cmd,
+		"should use pnpm for dependency installation")
+}
+
+func TestNodePrepare_InvalidPackageManager(t *testing.T) {
+	mock := &mockNodeTools{}
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: t.TempDir(),
+		Config: map[string]any{
+			"packageManager": "bun",
+		},
+	}
+
+	projCtx, err := prepareNodeProject(
+		t.Context(), mock, &mockCommandRunner{},
+		"/any/hook.js", execCtx,
+	)
+
+	require.Error(t, err)
+	assert.Nil(t, projCtx)
+	assert.Contains(t, err.Error(),
+		`invalid packageManager config value "bun"`)
+	assert.False(t, mock.installCalled)
+}
+
 // ---------------------------------------------------------------------------
 // buildNodeRunArgs tests
 // ---------------------------------------------------------------------------
diff --git a/cli/azd/pkg/tools/language/python_executor.go b/cli/azd/pkg/tools/language/python_executor.go
index 1b68fda96ef..3cdd61034e5 100644
--- a/cli/azd/pkg/tools/language/python_executor.go
+++ b/cli/azd/pkg/tools/language/python_executor.go
@@ -16,6 +16,15 @@ import (
 	"github.com/azure/azure-dev/cli/azd/pkg/tools/python"
 )
 
+// pythonHookConfig holds the executor-specific configuration
+// deserialized from the hook's "config" property bag.
+type pythonHookConfig struct {
+	// VirtualEnvName overrides the auto-detected virtual
+	// environment directory name (e.g. ".venv", "my_env").
+	// Must be a plain directory name with no path separators.
+	VirtualEnvName string `json:"virtualEnvName"`
+}
+
 // pythonTools abstracts the Python CLI operations needed by
 // pythonExecutor, decoupling it from the concrete [python.Cli]
 // for testability. [python.Cli] satisfies this interface.
@@ -72,12 +81,14 @@ func newPythonExecutorInternal(
 // dependencies. The venv naming convention follows
 // [python.VenvNameForDir]: {projectDirName}_env.
 //
-// Before creating a new venv, Prepare checks for an existing
-// virtual environment — either via the VIRTUAL_ENV environment
-// variable or well-known directory names (.venv, venv) in the
-// project path. When an existing venv is detected, creation is
-// skipped but dependency installation still runs when a Python
-// project file is present and the venv is inside the project.
+// An explicit virtualEnvName in the hook config always takes
+// precedence over auto-detection. When no config override is
+// set, Prepare checks for an existing virtual environment —
+// either via the VIRTUAL_ENV environment variable or well-known
+// directory names (.venv, venv) in the project path. When an
+// existing venv is detected, creation is skipped but dependency
+// installation still runs when a Python project file is present
+// and the venv is inside the project.
 func (e *pythonExecutor) Prepare(
 	ctx context.Context,
 	scriptPath string,
@@ -104,34 +115,59 @@ func (e *pythonExecutor) Prepare(
 		)
 	}
 
-	// 3. Detect existing virtual environment (VIRTUAL_ENV
-	//    env var or well-known directories).
-	if existing := detectExistingVenv(
-		execCtx, projCtx,
-	); existing != "" {
-		e.venvPath = existing
-
-		// Still install deps when a Python project file
-		// exists and the venv lives inside projectDir (so
-		// the python CLI can locate the activation script).
-		if projCtx != nil &&
-			projCtx.Language == HookKindPython {
-			if name, ok := relativeVenvName(
-				projCtx.ProjectDir, existing,
-			); ok {
-				depFile := filepath.Base(
-					projCtx.DependencyFile,
-				)
-				if err := e.pythonCli.InstallDependencies(
-					ctx, projCtx.ProjectDir,
-					name, depFile,
-					execCtx.EnvVars,
-				); err != nil {
-					return err
+	// 3. Parse config early — an explicit virtualEnvName
+	//    takes priority over auto-detected venvs.
+	cfg, err := tools.UnmarshalHookConfig[pythonHookConfig](
+		execCtx.Config,
+	)
+	if err != nil {
+		return fmt.Errorf(
+			"parsing python hook config: %w", err,
+		)
+	}
+
+	hasConfigVenv := cfg.VirtualEnvName != ""
+	if hasConfigVenv {
+		if err := validateVenvName(
+			cfg.VirtualEnvName,
+		); err != nil {
+			return err
+		}
+	}
+
+	// 4. Detect existing virtual environment (VIRTUAL_ENV
+	//    env var or well-known directories). Skip when
+	//    config explicitly specifies a venv name — the
+	//    user's override should always win.
+	if !hasConfigVenv {
+		if existing := detectExistingVenv(
+			execCtx, projCtx,
+		); existing != "" {
+			e.venvPath = existing
+
+			// Still install deps when a Python project
+			// file exists and the venv lives inside
+			// projectDir (so the python CLI can locate
+			// the activation script).
+			if projCtx != nil &&
+				projCtx.Language == HookKindPython {
+				if name, ok := relativeVenvName(
+					projCtx.ProjectDir, existing,
+				); ok {
+					depFile := filepath.Base(
+						projCtx.DependencyFile,
+					)
+					if err := e.pythonCli.InstallDependencies(
+						ctx, projCtx.ProjectDir,
+						name, depFile,
+						execCtx.EnvVars,
+					); err != nil {
+						return err
+					}
 				}
 			}
+			return nil
 		}
-		return nil
 	}
 
 	// No project file — run with system Python directly.
@@ -146,8 +182,17 @@ func (e *pythonExecutor) Prepare(
 		return nil
 	}
 
-	// 4. Set up virtual environment.
-	venvName := python.VenvNameForDir(projCtx.ProjectDir)
+	// 5. Resolve virtual environment name. Use the
+	//    config value if provided, otherwise fall back
+	//    to the directory-based default.
+	var venvName string
+	if hasConfigVenv {
+		venvName = cfg.VirtualEnvName
+	} else {
+		venvName = python.VenvNameForDir(
+			projCtx.ProjectDir,
+		)
+	}
 
 	if err := e.pythonCli.EnsureVirtualEnv(
 		ctx, projCtx.ProjectDir,
@@ -156,7 +201,7 @@ func (e *pythonExecutor) Prepare(
 		return err
 	}
 
-	// 5. Install dependencies from the discovered file.
+	// 6. Install dependencies from the discovered file.
 	depFile := filepath.Base(projCtx.DependencyFile)
 	if err := e.pythonCli.InstallDependencies(
 		ctx, projCtx.ProjectDir,
@@ -303,3 +348,28 @@ func relativeVenvName(
 	}
 	return rel, true
 }
+
+// validateVenvName checks that the user-supplied virtual
+// environment name is a plain directory name — no path
+// separators or traversal components are allowed.
+func validateVenvName(name string) error {
+	if strings.TrimSpace(name) == "" {
+		return fmt.Errorf(
+			"virtualEnvName must not be empty",
+		)
+	}
+	if name == "." || name == ".." {
+		return fmt.Errorf(
+			"virtualEnvName %q is not a valid "+
+				"directory name", name,
+		)
+	}
+	if strings.ContainsAny(name, "/\\") ||
+		strings.ContainsRune(name, os.PathSeparator) {
+		return fmt.Errorf(
+			"virtualEnvName %q must not contain "+
+				"path separators", name,
+		)
+	}
+	return nil
+}
diff --git a/cli/azd/pkg/tools/language/python_executor_test.go b/cli/azd/pkg/tools/language/python_executor_test.go
index 776860e2e49..3e863299afe 100644
--- a/cli/azd/pkg/tools/language/python_executor_test.go
+++ b/cli/azd/pkg/tools/language/python_executor_test.go
@@ -671,3 +671,217 @@ func TestPythonPrepare_VenvDirVenv(t *testing.T) {
 	assert.Equal(t, "venv", cli.depsVenv)
 	assert.Equal(t, "pyproject.toml", cli.depsFile)
 }
+
+// ---------------------------------------------------------------------------
+// virtualEnvName config tests
+// ---------------------------------------------------------------------------
+
+func TestPythonPrepare_VirtualEnvNameConfig(t *testing.T) {
+	tests := []struct {
+		name         string
+		config       map[string]any
+		wantVenvName string // expected EnsureVirtualEnv name
+		wantErr      string // substring of error, empty = no error
+	}{
+		{
+			name:         "DotVenvName",
+			config:       map[string]any{"virtualEnvName": ".venv"},
+			wantVenvName: ".venv",
+		},
+		{
+			name:         "CustomName",
+			config:       map[string]any{"virtualEnvName": "my_env"},
+			wantVenvName: "my_env",
+		},
+		{
+			name:         "NoConfig_FallsBackToAutoDetect",
+			config:       nil,
+			wantVenvName: "myproject_env",
+		},
+		{
+			name:         "EmptyConfig_FallsBackToAutoDetect",
+			config:       map[string]any{},
+			wantVenvName: "myproject_env",
+		},
+		{
+			name:    "EmptyString_Rejected",
+			config:  map[string]any{"virtualEnvName": "   "},
+			wantErr: "virtualEnvName must not be empty",
+		},
+		{
+			name:    "PathTraversal_Rejected",
+			config:  map[string]any{"virtualEnvName": "../evil"},
+			wantErr: "must not contain path separators",
+		},
+		{
+			name:    "ForwardSlash_Rejected",
+			config:  map[string]any{"virtualEnvName": "foo/bar"},
+			wantErr: "must not contain path separators",
+		},
+		{
+			name:    "BackSlash_Rejected",
+			config:  map[string]any{"virtualEnvName": `foo\bar`},
+			wantErr: "must not contain path separators",
+		},
+		{
+			name:    "Dot_Rejected",
+			config:  map[string]any{"virtualEnvName": "."},
+			wantErr: "is not a valid directory name",
+		},
+		{
+			name:    "DotDot_Rejected",
+			config:  map[string]any{"virtualEnvName": ".."},
+			wantErr: "is not a valid directory name",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			root := t.TempDir()
+			projectDir := filepath.Join(
+				root, "myproject",
+			)
+			hooksDir := filepath.Join(
+				projectDir, "hooks",
+			)
+			require.NoError(t,
+				os.MkdirAll(hooksDir, 0o700),
+			)
+			writeFile(t,
+				filepath.Join(
+					projectDir, "requirements.txt",
+				),
+				"flask\n",
+			)
+
+			cli := &mockPythonTools{}
+			e := newPythonExecutorInternal(
+				&mockCommandRunner{}, cli,
+			)
+
+			execCtx := tools.ExecutionContext{
+				BoundaryDir: root,
+				Config:      tt.config,
+			}
+			scriptPath := filepath.Join(
+				hooksDir, "deploy.py",
+			)
+			err := e.Prepare(
+				t.Context(), scriptPath, execCtx,
+			)
+
+			if tt.wantErr != "" {
+				require.Error(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				assert.False(t, cli.ensureVenvCalled,
+					"should not create venv on error",
+				)
+				return
+			}
+
+			require.NoError(t, err)
+			assert.True(t, cli.ensureVenvCalled)
+			assert.Equal(t,
+				tt.wantVenvName, cli.ensureVenvName,
+			)
+			assert.True(t, cli.installDepsCalled)
+			assert.Equal(t,
+				tt.wantVenvName, cli.depsVenv,
+			)
+			assert.Equal(t,
+				"requirements.txt", cli.depsFile,
+			)
+
+			expectedPath := filepath.Join(
+				projectDir, tt.wantVenvName,
+			)
+			assert.Equal(t, expectedPath, e.venvPath)
+		})
+	}
+}
+
+// TestPythonPrepare_ConfigOverridesDetectedVenv verifies that
+// an explicit virtualEnvName in the hook config takes priority
+// over a pre-existing .venv directory detected on disk.
+func TestPythonPrepare_ConfigOverridesDetectedVenv(t *testing.T) {
+	root := t.TempDir()
+	projectDir := filepath.Join(root, "myproject")
+	hooksDir := filepath.Join(projectDir, "hooks")
+	require.NoError(t, os.MkdirAll(hooksDir, 0o700))
+	writeFile(t,
+		filepath.Join(projectDir, "requirements.txt"),
+		"flask\n",
+	)
+
+	// Create a .venv directory with pyvenv.cfg — this
+	// would normally be auto-detected and used.
+	dotVenv := filepath.Join(projectDir, ".venv")
+	require.NoError(t, os.MkdirAll(dotVenv, 0o700))
+	writeFile(t,
+		filepath.Join(dotVenv, "pyvenv.cfg"),
+		"home = /usr/bin\n",
+	)
+
+	cli := &mockPythonTools{}
+	e := newPythonExecutorInternal(
+		&mockCommandRunner{}, cli,
+	)
+
+	// Config explicitly asks for "custom_env".
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: root,
+		Config: map[string]any{
+			"virtualEnvName": "custom_env",
+		},
+	}
+	scriptPath := filepath.Join(hooksDir, "deploy.py")
+	err := e.Prepare(t.Context(), scriptPath, execCtx)
+
+	require.NoError(t, err)
+
+	// Config should win — EnsureVirtualEnv is called with
+	// the config-specified name, not the detected ".venv".
+	assert.True(t, cli.ensureVenvCalled,
+		"should create/ensure the config-specified venv")
+	assert.Equal(t, "custom_env", cli.ensureVenvName,
+		"should use config virtualEnvName, not detected .venv")
+
+	assert.True(t, cli.installDepsCalled)
+	assert.Equal(t, "custom_env", cli.depsVenv)
+	assert.Equal(t, "requirements.txt", cli.depsFile)
+
+	expectedPath := filepath.Join(projectDir, "custom_env")
+	assert.Equal(t, expectedPath, e.venvPath,
+		"venvPath should reflect the config-specified name")
+}
+
+func TestValidateVenvName(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		wantErr bool
+	}{
+		{"ValidDotVenv", ".venv", false},
+		{"ValidCustom", "my_env", false},
+		{"ValidWithDots", ".my.env", false},
+		{"Empty", "", true},
+		{"Whitespace", "   ", true},
+		{"Dot", ".", true},
+		{"DotDot", "..", true},
+		{"ForwardSlash", "foo/bar", true},
+		{"BackSlash", `foo\bar`, true},
+		{"TrailingSlash", "venv/", true},
+		{"LeadingSlash", "/venv", true},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateVenvName(tt.input)
+			if tt.wantErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}
diff --git a/cli/azd/pkg/tools/language/ts_executor.go b/cli/azd/pkg/tools/language/ts_executor.go
index 1658b9c53d0..8fc0fbfbff6 100644
--- a/cli/azd/pkg/tools/language/ts_executor.go
+++ b/cli/azd/pkg/tools/language/ts_executor.go
@@ -51,7 +51,8 @@ func (e *tsExecutor) Prepare(
 	execCtx tools.ExecutionContext,
 ) error {
 	_, err := prepareNodeProject(
-		ctx, e.nodeCli, scriptPath, execCtx,
+		ctx, e.nodeCli, e.commandRunner,
+		scriptPath, execCtx,
 	)
 	return err
 }
diff --git a/cli/azd/pkg/tools/language/ts_executor_test.go b/cli/azd/pkg/tools/language/ts_executor_test.go
index 9037f4dc8ff..7443c1578b4 100644
--- a/cli/azd/pkg/tools/language/ts_executor_test.go
+++ b/cli/azd/pkg/tools/language/ts_executor_test.go
@@ -152,6 +152,59 @@ func TestTsCleanup_NoOp(t *testing.T) {
 	require.NoError(t, e.Cleanup(t.Context()))
 }
 
+func TestTsPrepare_PackageManagerOverride(t *testing.T) {
+	root := t.TempDir()
+	projectDir := filepath.Join(root, "project")
+	require.NoError(t, os.MkdirAll(projectDir, 0o700))
+	writeFile(t,
+		filepath.Join(projectDir, "package.json"),
+		`{"name": "test"}`,
+	)
+
+	mock := &mockNodeTools{}
+	runner := &mockCommandRunner{
+		runResult: exec.NewRunResult(
+			0, "v20.0.0", "",
+		),
+	}
+	e := newTSExecutorInternal(runner, mock)
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: root,
+		Config: map[string]any{
+			"packageManager": "yarn",
+		},
+	}
+	scriptPath := filepath.Join(projectDir, "hook.ts")
+
+	err := e.Prepare(t.Context(), scriptPath, execCtx)
+	require.NoError(t, err)
+
+	// Default mock bypassed — config override used yarn.
+	assert.False(t, mock.installCalled)
+	assert.Equal(t, "yarn", runner.lastRunArgs.Cmd)
+}
+
+func TestTsPrepare_InvalidPackageManager(t *testing.T) {
+	e := newTSExecutorInternal(
+		&mockCommandRunner{}, &mockNodeTools{},
+	)
+
+	execCtx := tools.ExecutionContext{
+		BoundaryDir: t.TempDir(),
+		Config: map[string]any{
+			"packageManager": "bun",
+		},
+	}
+
+	err := e.Prepare(
+		t.Context(), "/any/hook.ts", execCtx,
+	)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(),
+		`invalid packageManager config value "bun"`)
+}
+
 // ---------------------------------------------------------------------------
 // Table-driven comprehensive tests
 // ---------------------------------------------------------------------------
diff --git a/cli/azd/pkg/tools/script.go b/cli/azd/pkg/tools/script.go
index 0740aa516c4..8c66fbd3864 100644
--- a/cli/azd/pkg/tools/script.go
+++ b/cli/azd/pkg/tools/script.go
@@ -47,6 +47,13 @@ type ExecutionContext struct {
 	// "preprovision"). Used by executors for temp file naming to
 	// aid debuggability.
 	HookName string
+
+	// Config is the executor-specific property bag from HookConfig.
+	// Executors can unmarshal this into a typed struct for their
+	// configuration needs. May be nil or empty if no config was
+	// specified. Executors must not mutate this map — it is shared
+	// with the underlying HookConfig.
+	Config map[string]any
 }
 
 // HookExecutor is the unified interface for all hook execution.
diff --git a/schemas/alpha/azure.yaml.json b/schemas/alpha/azure.yaml.json
index 8b60cc53ae1..89405fc9e7a 100644
--- a/schemas/alpha/azure.yaml.json
+++ b/schemas/alpha/azure.yaml.json
@@ -886,6 +886,11 @@
                             "WITH_SECRET_VALUE": "ENV_VAR_WITH_SECRET"
                         }
                     ]
+                },
+                "config": {
+                    "type": "object",
+                    "title": "Executor-specific configuration",
+                    "description": "Optional configuration specific to the hook executor kind."
                 }
             },
             "allOf": [
@@ -912,7 +917,8 @@
                             "dir": false,
                             "interactive": false,
                             "continueOnError": false,
-                            "secrets": false
+                            "secrets": false,
+                            "config": false
                         }
                     }
                 },
@@ -948,6 +954,11 @@
                                 "required": [
                                     "dir"
                                 ]
+                            },
+                            {
+                                "required": [
+                                    "config"
+                                ]
                             }
                         ]
                     },
@@ -956,6 +967,66 @@
                             "run"
                         ]
                     }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "enum": ["js", "ts"] }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/jsHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "const": "python" }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/pythonHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "const": "dotnet" }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/dotnetHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "enum": ["sh", "pwsh"] }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/emptyHookConfig"
+                            }
+                        }
+                    }
                 }
             ]
         },
@@ -1897,6 +1968,57 @@
                     "default": false
                 }
             }
+        },
+        "jsHookConfig": {
+            "type": "object",
+            "title": "JavaScript/TypeScript hook configuration",
+            "description": "Configuration options for JS and TS hook executors.",
+            "additionalProperties": false,
+            "properties": {
+                "packageManager": {
+                    "type": "string",
+                    "title": "Package manager",
+                    "description": "The package manager to use for dependency installation. Overrides auto-detection from lock files.",
+                    "enum": ["npm", "pnpm", "yarn"]
+                }
+            }
+        },
+        "pythonHookConfig": {
+            "type": "object",
+            "title": "Python hook configuration",
+            "description": "Configuration options for the Python hook executor.",
+            "additionalProperties": false,
+            "properties": {
+                "virtualEnvName": {
+                    "type": "string",
+                    "title": "Virtual environment name",
+                    "description": "The directory name for the Python virtual environment. Defaults to auto-detection (.venv, venv) or {baseName}_env."
+                }
+            }
+        },
+        "dotnetHookConfig": {
+            "type": "object",
+            "title": ".NET hook configuration",
+            "description": "Configuration options for the .NET hook executor.",
+            "additionalProperties": false,
+            "properties": {
+                "configuration": {
+                    "type": "string",
+                    "title": "Build configuration",
+                    "description": "The MSBuild configuration for building the hook script (e.g., Debug, Release)."
+                },
+                "framework": {
+                    "type": "string",
+                    "title": "Target framework",
+                    "description": "The target framework moniker for building and running the hook script (e.g., net8.0, net10.0)."
+                }
+            }
+        },
+        "emptyHookConfig": {
+            "type": "object",
+            "title": "Shell hook configuration",
+            "description": "Shell executors (sh, pwsh) do not currently support config properties.",
+            "additionalProperties": false
         }
     }
 }
diff --git a/schemas/v1.0/azure.yaml.json b/schemas/v1.0/azure.yaml.json
index 90ffed2f2b1..0b7e74d60f8 100644
--- a/schemas/v1.0/azure.yaml.json
+++ b/schemas/v1.0/azure.yaml.json
@@ -846,6 +846,11 @@
                             "WITH_SECRET_VALUE": "ENV_VAR_WITH_SECRET"
                         }
                     ]
+                },
+                "config": {
+                    "type": "object",
+                    "title": "Executor-specific configuration",
+                    "description": "Optional configuration specific to the hook executor kind."
                 }
             },
             "allOf": [
@@ -872,7 +877,8 @@
                             "dir": false,
                             "interactive": false,
                             "continueOnError": false,
-                            "secrets": false
+                            "secrets": false,
+                            "config": false
                         }
                     }
                 },
@@ -908,6 +914,11 @@
                                 "required": [
                                     "dir"
                                 ]
+                            },
+                            {
+                                "required": [
+                                    "config"
+                                ]
                             }
                         ]
                     },
@@ -916,6 +927,66 @@
                             "run"
                         ]
                     }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "enum": ["js", "ts"] }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/jsHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "const": "python" }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/pythonHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "const": "dotnet" }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/dotnetHookConfig"
+                            }
+                        }
+                    }
+                },
+                {
+                    "if": {
+                        "properties": {
+                            "kind": { "enum": ["sh", "pwsh"] }
+                        },
+                        "required": ["kind"]
+                    },
+                    "then": {
+                        "properties": {
+                            "config": {
+                                "$ref": "#/definitions/emptyHookConfig"
+                            }
+                        }
+                    }
                 }
             ]
         },
@@ -1774,6 +1845,57 @@
                     "default": false
                 }
             }
+        },
+        "jsHookConfig": {
+            "type": "object",
+            "title": "JavaScript/TypeScript hook configuration",
+            "description": "Configuration options for JS and TS hook executors.",
+            "additionalProperties": false,
+            "properties": {
+                "packageManager": {
+                    "type": "string",
+                    "title": "Package manager",
+                    "description": "The package manager to use for dependency installation. Overrides auto-detection from lock files.",
+                    "enum": ["npm", "pnpm", "yarn"]
+                }
+            }
+        },
+        "pythonHookConfig": {
+            "type": "object",
+            "title": "Python hook configuration",
+            "description": "Configuration options for the Python hook executor.",
+            "additionalProperties": false,
+            "properties": {
+                "virtualEnvName": {
+                    "type": "string",
+                    "title": "Virtual environment name",
+                    "description": "The directory name for the Python virtual environment. Defaults to auto-detection (.venv, venv) or {baseName}_env."
+                }
+            }
+        },
+        "dotnetHookConfig": {
+            "type": "object",
+            "title": ".NET hook configuration",
+            "description": "Configuration options for the .NET hook executor.",
+            "additionalProperties": false,
+            "properties": {
+                "configuration": {
+                    "type": "string",
+                    "title": "Build configuration",
+                    "description": "The MSBuild configuration for building the hook script (e.g., Debug, Release)."
+                },
+                "framework": {
+                    "type": "string",
+                    "title": "Target framework",
+                    "description": "The target framework moniker for building and running the hook script (e.g., net8.0, net10.0)."
+                }
+            }
+        },
+        "emptyHookConfig": {
+            "type": "object",
+            "title": "Shell hook configuration",
+            "description": "Shell executors (sh, pwsh) do not currently support config properties.",
+            "additionalProperties": false
         }
     }
 }