Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

22.1 KB
Raw Blame
package config

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"github.com/pinchtab/pinchtab/internal/safelog"
)

// GetConfigValue reads a dotted-path field from FileConfig and returns its string representation.
// Pointer fields that are unset return an empty string. Slice fields are comma-separated.
// The section vocabulary lives once, in configSections.
func GetConfigValue(fc *FileConfig, path string) (string, error) {
	section, field, err := lookupConfigSection(path)
	if err != nil {
		return "", err
	}
	return section.get(fc, field)
}

func getServerField(s *ServerConfig, field string) (string, error) {
	switch field {
	case "port":
		return s.Port, nil
	case "bind":
		return s.Bind, nil
	case "token":
		return s.Token, nil
	case "stateDir":
		return s.StateDir, nil
	case "logLevel":
		return s.LogLevel, nil
	case "networkBufferSize":
		return formatIntPtr(s.NetworkBufferSize), nil
	case "retainNetworkBodies":
		return formatBoolPtr(s.RetainNetworkBodies), nil
	case "retainNetworkBodyMaxBytes":
		return formatIntPtr(s.RetainNetworkBodyMaxBytes), nil
	case "trustProxyHeaders":
		return formatBoolPtr(s.TrustProxyHeaders), nil
	case "cookieSecure":
		return formatBoolPtr(s.CookieSecure), nil
	default:
		return "", fmt.Errorf("unknown field server.%s", field)
	}
}

func getBrowserField(b *BrowserConfig, field string) (string, error) {
	if strings.HasPrefix(field, "cloak.") {
		return getCloakBrowserField(&b.Cloak, strings.TrimPrefix(field, "cloak."))
	}
	if strings.HasPrefix(field, "proxy.") {
		return getBrowserProxyField(&b.Proxy, strings.TrimPrefix(field, "proxy."))
	}
	if strings.HasPrefix(field, "targets.") {
		return getBrowserTargetField(b.Targets, strings.TrimPrefix(field, "targets."))
	}
	switch field {
	case "provider":
		return "", fmt.Errorf("browser.provider is no longer supported; use browsers.default")
	case "version":
		return b.BrowserVersion, nil
	case "binary":
		return b.BrowserBinary, nil
	case "extraFlags":
		return b.BrowserExtraFlags, nil
	case "remoteDebuggingPort":
		return formatIntPtr(b.BrowserDebugPort), nil
	case "extensionPaths":
		return strings.Join(b.ExtensionPaths, ","), nil
	case "defaultTarget":
		return b.DefaultTarget, nil
	case "fallbackOrder":
		return strings.Join(b.FallbackOrder, ","), nil
	default:
		return "", fmt.Errorf("unknown field browser.%s", field)
	}
}

// getBrowserProxyField returns proxy values plainly — like server.token, the
// CLI editor reads the operator's own file.
func getBrowserProxyField(p *BrowserProxyConfig, field string) (string, error) {
	if strings.HasPrefix(field, "geo.") {
		if p.Geo == nil {
			return "", nil
		}
		switch strings.TrimPrefix(field, "geo.") {
		case "timezone":
			return p.Geo.Timezone, nil
		case "locale":
			return p.Geo.Locale, nil
		case "webrtcIP":
			return p.Geo.WebRTCIP, nil
		case "countryISO":
			return p.Geo.CountryISO, nil
		default:
			return "", fmt.Errorf("unknown field proxy.%s", field)
		}
	}
	switch field {
	case "server":
		return p.Server, nil
	case "bypassList":
		return strings.Join(p.BypassList, ","), nil
	case "username":
		return p.Username, nil
	case "password":
		return p.Password, nil
	default:
		return "", fmt.Errorf("unknown field proxy.%s", field)
	}
}

func getBrowserTargetField(targets BrowserTargetsConfig, path string) (string, error) {
	name, field, ok := strings.Cut(path, ".")
	if !ok || name == "" || field == "" {
		return "", fmt.Errorf("invalid browser.targets path %q (expected targets.<name>.<field>)", path)
	}
	t, ok := targets[name]
	if !ok {
		return "", fmt.Errorf("browser target %q not found", name)
	}
	switch {
	case strings.HasPrefix(field, "cloak."):
		return getCloakBrowserField(&t.Cloak, strings.TrimPrefix(field, "cloak."))
	case strings.HasPrefix(field, "proxy."):
		return getBrowserProxyField(&t.Proxy, strings.TrimPrefix(field, "proxy."))
	case field == "provider":
		return t.Provider, nil
	case field == "binary":
		return t.Binary, nil
	case field == "extraFlags":
		return t.ExtraFlags, nil
	default:
		return "", fmt.Errorf("unknown field browser.targets.%s.%s", name, field)
	}
}

func getBrowsersField(b *BrowsersConfig, field string) (string, error) {
	switch field {
	case "default":
		return b.Default, nil
	case "available":
		return strings.Join(b.Available, ","), nil
	default:
		return "", fmt.Errorf("unknown field browsers.%s", field)
	}
}

func getCloakBrowserField(c *CloakBrowserConfig, field string) (string, error) {
	switch field {
	case "fingerprintSeed":
		return c.FingerprintSeed, nil
	case "platform":
		return c.Platform, nil
	case "locale":
		return c.Locale, nil
	case "timezone":
		return c.Timezone, nil
	case "webrtcIP":
		return c.WebRTCIP, nil
	case "fontsDir":
		return c.FontsDir, nil
	case "storageQuotaMB":
		return formatIntPtr(c.StorageQuotaMB), nil
	case "disableDefaultStealthArgs":
		return formatBoolPtr(c.DisableDefaultStealthArgs), nil
	default:
		return "", fmt.Errorf("unknown field browser.cloak.%s", field)
	}
}

func getObservabilityField(o *ObservabilityFileConfig, field string) (string, error) {
	if strings.HasPrefix(field, "activity.") {
		return getActivityField(&o.Activity, strings.TrimPrefix(field, "activity."))
	}
	return "", fmt.Errorf("unknown field observability.%s", field)
}

func getActivityField(a *ActivityFileConfig, field string) (string, error) {
	if strings.HasPrefix(field, "events.") {
		return getActivityEventField(&a.Events, strings.TrimPrefix(field, "events."))
	}

	switch field {
	case "enabled":
		return formatBoolPtr(a.Enabled), nil
	case "sessionIdleSec":
		return formatIntPtr(a.SessionIdleSec), nil
	case "retentionDays":
		return formatIntPtr(a.RetentionDays), nil
	case "stateDir":
		return a.StateDir, nil
	default:
		return "", fmt.Errorf("unknown field observability.activity.%s", field)
	}
}

func getActivityEventField(e *ActivityEventsFileConfig, field string) (string, error) {
	switch field {
	case "dashboard":
		return formatBoolPtr(e.Dashboard), nil
	case "server":
		return formatBoolPtr(e.Server), nil
	case "bridge":
		return formatBoolPtr(e.Bridge), nil
	case "orchestrator":
		return formatBoolPtr(e.Orchestrator), nil
	case "scheduler":
		return formatBoolPtr(e.Scheduler), nil
	case "mcp":
		return formatBoolPtr(e.MCP), nil
	case "other":
		return formatBoolPtr(e.Other), nil
	default:
		return "", fmt.Errorf("unknown field observability.activity.events.%s", field)
	}
}

func getSessionsField(s *SessionsFileConfig, field string) (string, error) {
	if strings.HasPrefix(field, "dashboard.") {
		return getDashboardSessionField(&s.Dashboard, strings.TrimPrefix(field, "dashboard."))
	}
	if strings.HasPrefix(field, "agent.") {
		return getAgentSessionField(&s.Agent, strings.TrimPrefix(field, "agent."))
	}
	return "", fmt.Errorf("unknown field sessions.%s", field)
}

// getAgentSessionField addresses the switch behind the whole agent-session flow. It was
// unreachable here while the schema declared it and the loader honoured it, so the only
// way to turn agent sessions on was to hand-edit JSON — and the editor answered "unknown
// field", which claims the key is wrong rather than that it is not settable here.
//
// The cases mirror AgentSessionFileConfig's declared fields, and
// TestTheSessionsEditorAddressesEveryDeclaredField walks that struct rather than this
// list: a hand-listed switch is how a field goes missing from a section that otherwise
// looks complete.
func getAgentSessionField(s *AgentSessionFileConfig, field string) (string, error) {
	switch field {
	case "enabled":
		return formatBoolPtr(s.Enabled), nil
	case "mode":
		return s.Mode, nil
	case "idleTimeoutSec":
		return formatIntPtr(s.IdleTimeoutSec), nil
	case "maxLifetimeSec":
		return formatIntPtr(s.MaxLifetimeSec), nil
	default:
		return "", fmt.Errorf("unknown field sessions.agent.%s", field)
	}
}

func getDashboardSessionField(s *DashboardSessionFileConfig, field string) (string, error) {
	switch field {
	case "persist":
		return formatBoolPtr(s.Persist), nil
	case "idleTimeoutSec":
		return formatIntPtr(s.IdleTimeoutSec), nil
	case "maxLifetimeSec":
		return formatIntPtr(s.MaxLifetimeSec), nil
	case "elevationWindowSec":
		return formatIntPtr(s.ElevationWindowSec), nil
	case "persistElevationAcrossRestart":
		return formatBoolPtr(s.PersistElevationAcrossRestart), nil
	case "requireElevation":
		return formatBoolPtr(s.RequireElevation), nil
	default:
		return "", fmt.Errorf("unknown field sessions.dashboard.%s", field)
	}
}

func getInstanceDefaultsField(c *InstanceDefaultsConfig, field string) (string, error) {
	if after, ok := strings.CutPrefix(field, "tabPolicy."); ok {
		return getTabPolicyField(c.TabPolicy, after)
	}
	switch field {
	case "mode":
		return c.Mode, nil
	case "noRestore":
		return formatBoolPtr(c.NoRestore), nil
	case "timezone":
		return c.Timezone, nil
	case "blockImages":
		return formatBoolPtr(c.BlockImages), nil
	case "blockMedia":
		return formatBoolPtr(c.BlockMedia), nil
	case "blockAds":
		return formatBoolPtr(c.BlockAds), nil
	case "maxTabs":
		return formatIntPtr(c.MaxTabs), nil
	case "maxParallelTabs":
		return formatIntPtr(c.MaxParallelTabs), nil
	case "userAgent":
		return c.UserAgent, nil
	case "noAnimations":
		return formatBoolPtr(c.NoAnimations), nil
	case "captureAllowActivation":
		return formatBoolPtr(c.CaptureAllowActivation), nil
	case "humanize":
		return formatBoolPtr(c.Humanize), nil
	case "stealthLevel":
		return c.StealthLevel, nil
	case "tabEvictionPolicy":
		return c.TabEvictionPolicy, nil
	case "dialogAutoAccept":
		return formatBoolPtr(c.DialogAutoAccept), nil
	default:
		return "", fmt.Errorf("unknown field instanceDefaults.%s", field)
	}
}

func getTabPolicyField(tp *TabPolicyDefaults, field string) (string, error) {
	if tp == nil {
		tp = &TabPolicyDefaults{}
	}
	switch field {
	case "eviction":
		return tp.Eviction, nil
	case "lifecycle":
		return tp.Lifecycle, nil
	case "closeDelaySec":
		return formatIntPtr(tp.CloseDelaySec), nil
	case "restore":
		return formatBoolPtr(tp.Restore), nil
	default:
		return "", fmt.Errorf("unknown field instanceDefaults.tabPolicy.%s", field)
	}
}

func getSecurityField(s *SecurityConfig, field string) (string, error) {
	if strings.HasPrefix(field, "attach.") {
		return getAttachField(&s.Attach, strings.TrimPrefix(field, "attach."))
	}
	if strings.HasPrefix(field, "idpi.") {
		return getIDPIField(s.IDPI, strings.TrimPrefix(field, "idpi."))
	}

	switch field {
	case "allowEvaluate":
		return formatBoolPtr(s.AllowEvaluate), nil
	case "allowClipboard":
		return formatBoolPtr(s.AllowClipboard), nil
	case "allowMacro":
		return formatBoolPtr(s.AllowMacro), nil
	case "allowScreencast":
		return formatBoolPtr(s.AllowScreencast), nil
	case "allowDownload":
		return formatBoolPtr(s.AllowDownload), nil
	case "allowCookies":
		return formatBoolPtr(s.AllowCookies), nil
	case "allowStateExport":
		return formatBoolPtr(s.AllowStateExport), nil
	case "stateEncryptionKey":
		return formatStringPtr(s.StateEncryptionKey), nil
	case "allowNetworkIntercept":
		return formatBoolPtr(s.AllowNetworkIntercept), nil
	case "allowMemory":
		return formatBoolPtr(s.AllowMemory), nil
	case "allowFileScheme":
		return formatBoolPtr(s.AllowFileScheme), nil
	case "allowedDomains":
		return strings.Join(s.AllowedDomains, ","), nil
	case "downloadAllowedDomains":
		return strings.Join(s.DownloadAllowedDomains, ","), nil
	case "downloadMaxBytes":
		return formatIntPtr(s.DownloadMaxBytes), nil
	case "memorySnapshotMaxBytes":
		return formatIntPtr(s.MemorySnapshotMaxBytes), nil
	case "allowUpload":
		return formatBoolPtr(s.AllowUpload), nil
	case "uploadMaxRequestBytes":
		return formatIntPtr(s.UploadMaxRequestBytes), nil
	case "uploadMaxFiles":
		return formatIntPtr(s.UploadMaxFiles), nil
	case "uploadMaxFileBytes":
		return formatIntPtr(s.UploadMaxFileBytes), nil
	case "uploadMaxTotalBytes":
		return formatIntPtr(s.UploadMaxTotalBytes), nil
	case "maxRedirects":
		return formatIntPtr(s.MaxRedirects), nil
	case "trustedProxyCIDRs":
		return strings.Join(s.TrustedProxyCIDRs, ","), nil
	case "trustedResolveCIDRs":
		return strings.Join(s.TrustedResolveCIDRs, ","), nil
	case "trustLoopbackProxy":
		return formatBoolPtr(s.TrustLoopbackProxy), nil
	default:
		return "", fmt.Errorf("unknown field security.%s", field)
	}
}

func getProfilesField(p *ProfilesConfig, field string) (string, error) {
	switch field {
	case "baseDir":
		return p.BaseDir, nil
	case "defaultProfile":
		return p.DefaultProfile, nil
	case "quarantineKeep":
		if p.QuarantineKeep == nil {
			return "", nil
		}
		return strconv.Itoa(*p.QuarantineKeep), nil
	default:
		return "", fmt.Errorf("unknown field profiles.%s", field)
	}
}

func getMultiInstanceField(o *MultiInstanceConfig, field string) (string, error) {
	if strings.HasPrefix(field, "restart.") {
		return getMultiInstanceRestartField(&o.Restart, strings.TrimPrefix(field, "restart."))
	}

	switch field {
	case "strategy":
		return o.Strategy, nil
	case "allocationPolicy":
		return o.AllocationPolicy, nil
	case "instancePortStart":
		return formatIntPtr(o.InstancePortStart), nil
	case "instancePortEnd":
		return formatIntPtr(o.InstancePortEnd), nil
	default:
		return "", fmt.Errorf("unknown field multiInstance.%s", field)
	}
}

func getMultiInstanceRestartField(r *MultiInstanceRestartConfig, field string) (string, error) {
	switch field {
	case "maxRestarts":
		return formatIntPtr(r.MaxRestarts), nil
	case "initBackoffSec":
		return formatIntPtr(r.InitBackoffSec), nil
	case "maxBackoffSec":
		return formatIntPtr(r.MaxBackoffSec), nil
	case "stableAfterSec":
		return formatIntPtr(r.StableAfterSec), nil
	default:
		return "", fmt.Errorf("unknown field multiInstance.restart.%s", field)
	}
}

func getAttachField(a *AttachConfig, field string) (string, error) {
	switch field {
	case "enabled":
		return formatBoolPtr(a.Enabled), nil
	case "allowHosts":
		return strings.Join(a.AllowHosts, ","), nil
	case "allowSchemes":
		return strings.Join(a.AllowSchemes, ","), nil
	case "forwardProxyAuth":
		return formatBoolPtr(a.ForwardProxyAuth), nil
	default:
		return "", fmt.Errorf("unknown field security.attach.%s", field)
	}
}

func getIDPIField(i *IDPIConfig, field string) (string, error) {
	if i == nil {
		i = &IDPIConfig{}
	}
	switch field {
	case "enabled":
		return strconv.FormatBool(i.Enabled), nil
	case "strictMode":
		return strconv.FormatBool(i.StrictMode), nil
	case "scanContent":
		return strconv.FormatBool(i.ScanContent), nil
	case "wrapContent":
		return strconv.FormatBool(i.WrapContent), nil
	case "customPatterns":
		return strings.Join(i.CustomPatterns, ","), nil
	case "scanTimeoutSec":
		return strconv.Itoa(i.ScanTimeoutSec), nil
	case "shieldThreshold":
		return strconv.Itoa(i.ShieldThreshold), nil
	default:
		return "", fmt.Errorf("unknown field security.idpi.%s", field)
	}
}

func getTimeoutsField(t *TimeoutsConfig, field string) (string, error) {
	switch field {
	case "actionSec":
		return strconv.Itoa(t.ActionSec), nil
	case "navigateSec":
		return strconv.Itoa(t.NavigateSec), nil
	case "shutdownSec":
		return strconv.Itoa(t.ShutdownSec), nil
	case "waitNavMs":
		return strconv.Itoa(t.WaitNavMs), nil
	default:
		return "", fmt.Errorf("unknown field timeouts.%s", field)
	}
}

func formatBoolPtr(b *bool) string {
	if b == nil {
		return ""
	}
	if *b {
		return "true"
	}
	return "false"
}

func formatStringPtr(s *string) string {
	if s == nil {
		return ""
	}
	return *s
}

func formatIntPtr(n *int) string {
	if n == nil {
		return ""
	}
	return strconv.Itoa(*n)
}

func getSchedulerField(s *SchedulerFileConfig, field string) (string, error) {
	switch field {
	case "enabled":
		return formatBoolPtr(s.Enabled), nil
	case "strategy":
		return s.Strategy, nil
	case "maxQueueSize":
		return formatIntPtr(s.MaxQueueSize), nil
	case "maxPerAgent":
		return formatIntPtr(s.MaxPerAgent), nil
	case "maxInflight":
		return formatIntPtr(s.MaxInflight), nil
	case "maxPerAgentInflight":
		return formatIntPtr(s.MaxPerAgentFlight), nil
	case "resultTTLSec":
		return formatIntPtr(s.ResultTTLSec), nil
	case "workerCount":
		return formatIntPtr(s.WorkerCount), nil
	case "maxBatchSize":
		return formatIntPtr(s.MaxBatchSize), nil
	default:
		return "", fmt.Errorf("unknown field scheduler.%s", field)
	}
}

func getAutoSolverField(a *AutoSolverFileConfig, field string) (string, error) {
	if rest, ok := strings.CutPrefix(field, "external."); ok {
		return getAutoSolverExternalField(&a.External, rest)
	}
	if rest, ok := strings.CutPrefix(field, "credentials."); ok {
		return getAutoSolverCredentialsField(&a.Credentials, rest)
	}

	switch field {
	case "enabled":
		return formatBoolPtr(a.Enabled), nil
	case "autoTrigger":
		return formatBoolPtr(a.AutoTrigger), nil
	case "triggerOnNavigate":
		return formatBoolPtr(a.TriggerOnNavigate), nil
	case "triggerOnAction":
		return formatBoolPtr(a.TriggerOnAction), nil
	case "llmFallback":
		return formatBoolPtr(a.LLMFallback), nil
	case "maxAttempts":
		return formatIntPtr(a.MaxAttempts), nil
	case "solverTimeoutSec":
		return formatIntPtr(a.SolverTimeoutSec), nil
	case "retryBaseDelayMs":
		return formatIntPtr(a.RetryBaseDelayMs), nil
	case "retryMaxDelayMs":
		return formatIntPtr(a.RetryMaxDelayMs), nil
	case "llmProvider":
		return a.LLMProvider, nil
	case "solvers":
		return strings.Join(a.Solvers, ","), nil
	default:
		return "", fmt.Errorf("unknown field autoSolver.%s", field)
	}
}

func getAutoSolverExternalField(e *AutoSolverExtConf, field string) (string, error) {
	switch field {
	case "capsolverKey":
		return e.CapsolverKey, nil
	case "twoCaptchaKey":
		return e.TwoCaptchaKey, nil
	default:
		return "", fmt.Errorf("unknown field autoSolver.external.%s", field)
	}
}

func getAutoSolverCredentialsField(c *AutoSolverCredentialsConf, field string) (string, error) {
	switch {
	case strings.HasPrefix(field, "login."):
		switch strings.TrimPrefix(field, "login.") {
		case "user":
			return c.Login.User, nil
		case "password":
			return c.Login.Password, nil
		}
	case strings.HasPrefix(field, "signup."):
		switch strings.TrimPrefix(field, "signup.") {
		case "name":
			return c.Signup.Name, nil
		case "email":
			return c.Signup.Email, nil
		case "password":
			return c.Signup.Password, nil
		}
	case strings.HasPrefix(field, "form."):
		switch strings.TrimPrefix(field, "form.") {
		case "field1":
			return c.Form.Field1, nil
		case "field2":
			return c.Form.Field2, nil
		case "email":
			return c.Form.Email, nil
		}
	}
	return "", fmt.Errorf("unknown field autoSolver.credentials.%s", field)
}

// EffectiveConfigValue answers with the value in effect for a dotted path: the file
// value when the file sets one, otherwise the value the runtime resolves. Keys whose
// effective value is derived from another key, or whose default is applied by a
// consumer rather than stored in the config struct, are only visible this way.
func EffectiveConfigValue(path string) (string, error) {
	fc, _, err := LoadFileConfig()
	if err != nil {
		return "", fmt.Errorf("load config: %w", err)
	}
	value, err := GetConfigValue(fc, path)
	if err != nil {
		return "", err
	}
	if strings.TrimSpace(value) != "" && !runtimeSettlesTheValue(path) {
		return value, nil
	}
	return resolvedConfigValue(path)
}

// runtimeSettlesTheValue marks the paths whose file entry is an input rather than the
// answer, so reading the file would report something nothing acts on:
//
//	scheduler.*                      a configured zero means "use the default" here
//	observability.activity.stateDir  the path derives from server.stateDir; a file value
//	                                 is refused at config set and warned about at load
func runtimeSettlesTheValue(path string) bool {
	return strings.HasPrefix(path, "scheduler.") || path == "observability.activity.stateDir"
}

func resolvedConfigValue(path string) (string, error) {
	cfg, _, err := LoadConfig()
	if err != nil {
		return "", fmt.Errorf("load config: %w", err)
	}
	resolved := FileConfigFromRuntime(cfg)
	addSettledDefaults(&resolved, cfg)
	return GetConfigValue(&resolved, path)
}

// addSettledDefaults fills the sections FileConfigFromRuntime leaves out on purpose:
// it serialises configs for writing, where emitting every default would add noise to
// a file the operator did not ask for. The reader needs the opposite, so it takes the
// values back off the RuntimeConfig that has already settled them — never from a
// literal spelled here, which would be a second copy free to drift.
func addSettledDefaults(resolved *FileConfig, cfg *RuntimeConfig) {
	if strings.TrimSpace(resolved.Server.LogLevel) == "" {
		resolved.Server.LogLevel = safelog.LevelName(safelog.DefaultLevel)
	}
	// The writer omits a false tab-restore (a vanilla tab policy is left out of a file the
	// operator did not ask for) and omits the state encryption key entirely, so a generated
	// child instance config never carries a secret. Both are settled values a reader has to
	// see, taken off the RuntimeConfig rather than restated here.
	if resolved.InstanceDefaults.TabPolicy == nil {
		resolved.InstanceDefaults.TabPolicy = &TabPolicyDefaults{}
	}
	if resolved.InstanceDefaults.TabPolicy.Restore == nil {
		resolved.InstanceDefaults.TabPolicy.Restore = boolPtrValue(cfg.TabRestore)
	}
	if resolved.Security.StateEncryptionKey == nil && cfg.StateEncryptionKey != "" {
		key := cfg.StateEncryptionKey
		resolved.Security.StateEncryptionKey = &key
	}
	resolved.Scheduler = SchedulerFileConfig{
		Enabled:           boolPtrValue(cfg.Scheduler.Enabled),
		Strategy:          cfg.Scheduler.Strategy,
		MaxQueueSize:      intPtrIfPositive(cfg.Scheduler.MaxQueueSize),
		MaxPerAgent:       intPtrIfPositive(cfg.Scheduler.MaxPerAgent),
		MaxInflight:       intPtrIfPositive(cfg.Scheduler.MaxInflight),
		MaxPerAgentFlight: intPtrIfPositive(cfg.Scheduler.MaxPerAgentFlight),
		ResultTTLSec:      intPtrIfPositive(cfg.Scheduler.ResultTTLSec),
		WorkerCount:       intPtrIfPositive(cfg.Scheduler.WorkerCount),
		MaxBatchSize:      intPtrIfPositive(cfg.Scheduler.MaxBatchSize),
	}
	if resolved.InstanceDefaults.TabPolicy == nil {
		resolved.InstanceDefaults.TabPolicy = &TabPolicyDefaults{}
	}
	tabPolicy := resolved.InstanceDefaults.TabPolicy
	if tabPolicy.Eviction == "" {
		tabPolicy.Eviction = cfg.TabEvictionPolicy
	}
	if tabPolicy.Lifecycle == "" {
		tabPolicy.Lifecycle = cfg.TabLifecyclePolicy
	}
	if tabPolicy.CloseDelaySec == nil {
		tabPolicy.CloseDelaySec = intPtrIfPositive(int(cfg.TabCloseDelay / time.Second))
	}
	if strings.TrimSpace(resolved.Observability.Activity.StateDir) == "" {
		resolved.Observability.Activity.StateDir = cfg.ActivityLogDir()
	}
}