@jmoyers/harness 0.1.10 → 0.1.20

package/src/config/config-core.ts

@@ -7,8 +7,13 @@ import {
   unlinkSync,
   writeFileSync,
 } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  DEFAULT_STORAGE_LIFECYCLE_POLICY,
+  type StorageLifecyclePolicy,
+} from '../storage/storage-lifecycle-core.ts';
 
 export const HARNESS_CONFIG_FILE_NAME = 'harness.config.jsonc';
 export const HARNESS_CONFIG_VERSION = 1;
@@ -40,13 +45,46 @@ const HARNESS_LIFECYCLE_EVENT_TYPES = [
 
 export type HarnessLifecycleEventType = (typeof HARNESS_LIFECYCLE_EVENT_TYPES)[number];
 
+export const HARNESS_MUX_OPEN_IN_TARGET_IDS = [
+  'iterm2',
+  'ghostty',
+  'zed',
+  'cursor',
+  'vscode',
+  'warp',
+  'finder',
+] as const;
+
+export type HarnessMuxOpenInTargetId = (typeof HARNESS_MUX_OPEN_IN_TARGET_IDS)[number];
+
+export interface HarnessMuxOpenInTargetOverrideConfig {
+  readonly enabled?: boolean;
+  readonly appName?: string;
+  readonly detectCommand?: string | null;
+  readonly launchCommand?: readonly string[];
+}
+
+interface HarnessMuxOpenInLinkConfig {
+  readonly browserCommand: readonly string[] | null;
+  readonly fileCommand: readonly string[] | null;
+}
+
+interface HarnessMuxOpenInConfig {
+  readonly targets: Readonly<
+    Partial<Record<HarnessMuxOpenInTargetId, HarnessMuxOpenInTargetOverrideConfig>>
+  >;
+  readonly links: HarnessMuxOpenInLinkConfig;
+}
+
 interface HarnessMuxConfig {
   readonly keybindings: Readonly<Record<string, readonly string[]>>;
   readonly ui: HarnessMuxUiConfig;
   readonly git: HarnessMuxGitConfig;
+  readonly openIn: HarnessMuxOpenInConfig;
 }
 
 type HarnessMuxThemeMode = 'dark' | 'light';
+type HarnessMuxStartupPane = 'home' | 'nim';
 
 export interface HarnessMuxThemeConfig {
   readonly preset: string;
@@ -58,6 +96,9 @@ interface HarnessMuxUiConfig {
   readonly paneWidthPercent: number | null;
   readonly repositoriesCollapsed: boolean;
   readonly shortcutsCollapsed: boolean;
+  readonly startupPane: HarnessMuxStartupPane;
+  readonly showTasks: boolean;
+  readonly showDebugBar: boolean;
   readonly theme: HarnessMuxThemeConfig | null;
 }
 
@@ -83,6 +124,16 @@ interface HarnessGitHubConfig {
   readonly viewerLogin: string | null;
 }
 
+interface HarnessLinearConfig {
+  readonly enabled: boolean;
+  readonly apiBaseUrl: string;
+  readonly tokenEnvVar: string;
+}
+
+interface HarnessGatewayConfig {
+  readonly host: string;
+}
+
 interface HarnessPerfConfig {
   readonly enabled: boolean;
   readonly filePath: string;
@@ -215,15 +266,24 @@ interface HarnessHooksConfig {
   readonly lifecycle: HarnessLifecycleHooksConfig;
 }
 
+export type HarnessStorageLifecycleConfig = StorageLifecyclePolicy;
+
+interface HarnessStorageConfig {
+  readonly lifecycle: HarnessStorageLifecycleConfig;
+}
+
 interface HarnessConfig {
   readonly configVersion: number;
   readonly mux: HarnessMuxConfig;
   readonly github: HarnessGitHubConfig;
+  readonly gateway: HarnessGatewayConfig;
+  readonly linear: HarnessLinearConfig;
   readonly debug: HarnessDebugConfig;
   readonly codex: HarnessCodexConfig;
   readonly claude: HarnessClaudeConfig;
   readonly cursor: HarnessCursorConfig;
   readonly critique: HarnessCritiqueConfig;
+  readonly storage: HarnessStorageConfig;
   readonly hooks: HarnessHooksConfig;
 }
 
@@ -242,6 +302,9 @@ export const DEFAULT_HARNESS_CONFIG: HarnessConfig = {
       paneWidthPercent: null,
       repositoriesCollapsed: false,
       shortcutsCollapsed: false,
+      startupPane: 'home',
+      showTasks: false,
+      showDebugBar: false,
       theme: null,
     },
     git: {
@@ -253,6 +316,13 @@ export const DEFAULT_HARNESS_CONFIG: HarnessConfig = {
       triggerDebounceMs: 180,
       maxConcurrency: 1,
     },
+    openIn: {
+      targets: {},
+      links: {
+        browserCommand: null,
+        fileCommand: null,
+      },
+    },
   },
   github: {
     enabled: true,
@@ -263,6 +333,14 @@ export const DEFAULT_HARNESS_CONFIG: HarnessConfig = {
     branchStrategy: 'pinned-then-current',
     viewerLogin: null,
   },
+  gateway: {
+    host: '127.0.0.1',
+  },
+  linear: {
+    enabled: true,
+    apiBaseUrl: 'https://api.linear.app/graphql',
+    tokenEnvVar: 'LINEAR_API_KEY',
+  },
   debug: {
     enabled: true,
     overwriteArtifactsOnStart: true,
@@ -335,6 +413,11 @@ export const DEFAULT_HARNESS_CONFIG: HarnessConfig = {
       command: 'bun add --global critique@latest',
     },
   },
+  storage: {
+    lifecycle: {
+      ...DEFAULT_STORAGE_LIFECYCLE_POLICY,
+    },
+  },
   hooks: {
     lifecycle: {
       enabled: false,
@@ -538,6 +621,16 @@ function normalizeMuxThemeMode(value: unknown, fallback: HarnessMuxThemeMode): H
   return fallback;
 }
 
+function normalizeMuxStartupPane(
+  value: unknown,
+  fallback: HarnessMuxStartupPane,
+): HarnessMuxStartupPane {
+  if (value === 'home' || value === 'nim') {
+    return value;
+  }
+  return fallback;
+}
+
 function normalizeMuxThemeConfig(input: unknown): HarnessMuxThemeConfig | null {
   if (input === null || input === false) {
     return null;
@@ -573,18 +666,33 @@ function normalizeMuxUiConfig(input: unknown): HarnessMuxUiConfig {
     record['paneWidthPercent'],
     DEFAULT_HARNESS_CONFIG.mux.ui.paneWidthPercent,
   );
-  const shortcutsCollapsed =
-    typeof record['shortcutsCollapsed'] === 'boolean'
-      ? record['shortcutsCollapsed']
-      : DEFAULT_HARNESS_CONFIG.mux.ui.shortcutsCollapsed;
   const repositoriesCollapsed =
     typeof record['repositoriesCollapsed'] === 'boolean'
       ? record['repositoriesCollapsed']
       : DEFAULT_HARNESS_CONFIG.mux.ui.repositoriesCollapsed;
+  const shortcutsCollapsed =
+    typeof record['shortcutsCollapsed'] === 'boolean'
+      ? record['shortcutsCollapsed']
+      : DEFAULT_HARNESS_CONFIG.mux.ui.shortcutsCollapsed;
+  const startupPane = normalizeMuxStartupPane(
+    record['startupPane'],
+    DEFAULT_HARNESS_CONFIG.mux.ui.startupPane,
+  );
+  const showTasks =
+    typeof record['showTasks'] === 'boolean'
+      ? record['showTasks']
+      : DEFAULT_HARNESS_CONFIG.mux.ui.showTasks;
+  const showDebugBar =
+    typeof record['showDebugBar'] === 'boolean'
+      ? record['showDebugBar']
+      : DEFAULT_HARNESS_CONFIG.mux.ui.showDebugBar;
   return {
     paneWidthPercent,
     repositoriesCollapsed,
     shortcutsCollapsed,
+    startupPane,
+    showTasks,
+    showDebugBar,
     theme: normalizeMuxThemeConfig(record['theme']),
   };
 }
@@ -629,6 +737,113 @@ function normalizeMuxGitConfig(input: unknown): HarnessMuxGitConfig {
   };
 }
 
+function normalizeMuxOpenInTargetOverride(
+  input: unknown,
+): HarnessMuxOpenInTargetOverrideConfig | null {
+  const record = asRecord(input);
+  if (record === null) {
+    return null;
+  }
+  const enabled = typeof record['enabled'] === 'boolean' ? record['enabled'] : undefined;
+  const appName =
+    typeof record['appName'] === 'string' && record['appName'].trim().length > 0
+      ? record['appName'].trim()
+      : undefined;
+  const detectCommand =
+    record['detectCommand'] === null
+      ? null
+      : typeof record['detectCommand'] === 'string' && record['detectCommand'].trim().length > 0
+        ? record['detectCommand'].trim()
+        : undefined;
+  const launchCommandFromArray = Array.isArray(record['launchCommand'])
+    ? record['launchCommand']
+        .flatMap((entry) => (typeof entry === 'string' ? [entry.trim()] : []))
+        .filter((entry) => entry.length > 0)
+    : null;
+  const launchCommand =
+    launchCommandFromArray !== null
+      ? launchCommandFromArray.length > 0
+        ? launchCommandFromArray
+        : undefined
+      : typeof record['launchCommand'] === 'string' && record['launchCommand'].trim().length > 0
+        ? [record['launchCommand'].trim()]
+        : undefined;
+  if (
+    enabled === undefined &&
+    appName === undefined &&
+    detectCommand === undefined &&
+    launchCommand === undefined
+  ) {
+    return null;
+  }
+  return {
+    ...(enabled === undefined ? {} : { enabled }),
+    ...(appName === undefined ? {} : { appName }),
+    ...(detectCommand === undefined ? {} : { detectCommand }),
+    ...(launchCommand === undefined ? {} : { launchCommand }),
+  };
+}
+
+function normalizeOpenInLinkCommand(
+  input: unknown,
+  fallback: readonly string[] | null,
+): readonly string[] | null {
+  if (input === null) {
+    return null;
+  }
+  if (Array.isArray(input)) {
+    const normalized = input
+      .flatMap((entry) => (typeof entry === 'string' ? [entry.trim()] : []))
+      .filter((entry) => entry.length > 0);
+    return normalized.length > 0 ? normalized : null;
+  }
+  if (typeof input === 'string' && input.trim().length > 0) {
+    return [input.trim()];
+  }
+  return fallback;
+}
+
+function normalizeMuxOpenInLinksConfig(input: unknown): HarnessMuxOpenInLinkConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.mux.openIn.links;
+  }
+  return {
+    browserCommand: normalizeOpenInLinkCommand(
+      record['browserCommand'],
+      DEFAULT_HARNESS_CONFIG.mux.openIn.links.browserCommand,
+    ),
+    fileCommand: normalizeOpenInLinkCommand(
+      record['fileCommand'],
+      DEFAULT_HARNESS_CONFIG.mux.openIn.links.fileCommand,
+    ),
+  };
+}
+
+function normalizeMuxOpenInConfig(input: unknown): HarnessMuxOpenInConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.mux.openIn;
+  }
+  const targetsRecord = asRecord(record['targets']);
+  const normalizedTargets: Partial<
+    Record<HarnessMuxOpenInTargetId, HarnessMuxOpenInTargetOverrideConfig>
+  > = {};
+  if (targetsRecord !== null) {
+    for (const targetId of HARNESS_MUX_OPEN_IN_TARGET_IDS) {
+      const raw = targetsRecord[targetId];
+      const normalized = normalizeMuxOpenInTargetOverride(raw);
+      if (normalized !== null) {
+        normalizedTargets[targetId] = normalized;
+      }
+    }
+  }
+  return {
+    targets: normalizedTargets,
+    links: normalizeMuxOpenInLinksConfig(record['links']),
+  };
+}
+
 function normalizeGitHubBranchStrategy(value: unknown): HarnessGitHubBranchStrategy {
   if (value === 'current-only' || value === 'pinned-only' || value === 'pinned-then-current') {
     return value;
@@ -679,6 +894,41 @@ function normalizeGitHubConfig(input: unknown): HarnessGitHubConfig {
   };
 }
 
+function normalizeGatewayConfig(input: unknown): HarnessGatewayConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.gateway;
+  }
+  return {
+    host: normalizeHost(record['host'], DEFAULT_HARNESS_CONFIG.gateway.host),
+  };
+}
+
+function normalizeLinearConfig(input: unknown): HarnessLinearConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.linear;
+  }
+  const tokenEnvVarRaw = record['tokenEnvVar'];
+  const tokenEnvVar =
+    typeof tokenEnvVarRaw === 'string' && tokenEnvVarRaw.trim().length > 0
+      ? tokenEnvVarRaw.trim()
+      : DEFAULT_HARNESS_CONFIG.linear.tokenEnvVar;
+  const apiBaseUrlRaw = record['apiBaseUrl'];
+  const apiBaseUrl =
+    typeof apiBaseUrlRaw === 'string' && apiBaseUrlRaw.trim().length > 0
+      ? apiBaseUrlRaw.trim().replace(/\/+$/u, '')
+      : DEFAULT_HARNESS_CONFIG.linear.apiBaseUrl;
+  return {
+    enabled:
+      typeof record['enabled'] === 'boolean'
+        ? record['enabled']
+        : DEFAULT_HARNESS_CONFIG.linear.enabled,
+    apiBaseUrl,
+    tokenEnvVar,
+  };
+}
+
 function normalizePerfConfig(input: unknown): HarnessPerfConfig {
   const record = asRecord(input);
   if (record === null) {
@@ -709,6 +959,14 @@ function normalizeNonNegativeInt(value: unknown, fallback: number): number {
   return normalized;
 }
 
+function normalizePositiveInt(value: unknown, fallback: number): number {
+  const normalized = normalizeNonNegativeInt(value, fallback);
+  if (normalized < 1) {
+    return fallback;
+  }
+  return normalized;
+}
+
 function normalizeDebugMuxConfig(input: unknown): HarnessDebugMuxConfig {
   const record = asRecord(input);
   if (record === null) {
@@ -1304,6 +1562,69 @@ function normalizeLifecycleWebhookConfig(
   };
 }
 
+function normalizeStorageLifecycleConfig(input: unknown): HarnessStorageLifecycleConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.storage.lifecycle;
+  }
+  return {
+    eventRetentionMs: normalizePositiveInt(
+      record['eventRetentionMs'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.eventRetentionMs,
+    ),
+    telemetryRetentionMs: normalizePositiveInt(
+      record['telemetryRetentionMs'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.telemetryRetentionMs,
+    ),
+    maintenanceIntervalMs: normalizePositiveInt(
+      record['maintenanceIntervalMs'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.maintenanceIntervalMs,
+    ),
+    pruneBatchSize: normalizePositiveInt(
+      record['pruneBatchSize'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.pruneBatchSize,
+    ),
+    compactFreelistPages: normalizePositiveInt(
+      record['compactFreelistPages'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.compactFreelistPages,
+    ),
+    copyForwardBatchSize: normalizePositiveInt(
+      record['copyForwardBatchSize'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.copyForwardBatchSize,
+    ),
+    copyForwardFinalizeTailRows: normalizePositiveInt(
+      record['copyForwardFinalizeTailRows'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.copyForwardFinalizeTailRows,
+    ),
+    telemetryPayloadMaxBytes: normalizePositiveInt(
+      record['telemetryPayloadMaxBytes'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.telemetryPayloadMaxBytes,
+    ),
+    textDeltaPayloadMaxBytes: normalizePositiveInt(
+      record['textDeltaPayloadMaxBytes'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.textDeltaPayloadMaxBytes,
+    ),
+    textDeltaCoalesceWindowMs: normalizePositiveInt(
+      record['textDeltaCoalesceWindowMs'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.textDeltaCoalesceWindowMs,
+    ),
+    busyTimeoutMs: normalizePositiveInt(
+      record['busyTimeoutMs'],
+      DEFAULT_HARNESS_CONFIG.storage.lifecycle.busyTimeoutMs,
+    ),
+  };
+}
+
+function normalizeStorageConfig(input: unknown): HarnessStorageConfig {
+  const record = asRecord(input);
+  if (record === null) {
+    return DEFAULT_HARNESS_CONFIG.storage;
+  }
+  return {
+    lifecycle: normalizeStorageLifecycleConfig(record['lifecycle']),
+  };
+}
+
 function normalizeLifecycleHooksConfig(input: unknown): HarnessLifecycleHooksConfig {
   const record = asRecord(input);
   if (record === null) {
@@ -1371,12 +1692,15 @@ export function parseHarnessConfigText(text: string): HarnessConfig {
 
   const mux = asRecord(migratedRoot['mux']);
   const github = normalizeGitHubConfig(migratedRoot['github']);
+  const gateway = normalizeGatewayConfig(migratedRoot['gateway']);
+  const linear = normalizeLinearConfig(migratedRoot['linear']);
   const legacyPerf = normalizePerfConfig(migratedRoot['perf']);
   const debug = normalizeDebugConfig(migratedRoot['debug'], legacyPerf);
   const codex = normalizeCodexConfig(migratedRoot['codex']);
   const claude = normalizeClaudeConfig(migratedRoot['claude']);
   const cursor = normalizeCursorConfig(migratedRoot['cursor']);
   const critique = normalizeCritiqueConfig(migratedRoot['critique']);
+  const storage = normalizeStorageConfig(migratedRoot['storage']);
   const hooks = normalizeLifecycleHooksConfig(asRecord(migratedRoot['hooks'])?.['lifecycle']);
 
   return {
@@ -1385,13 +1709,18 @@ export function parseHarnessConfigText(text: string): HarnessConfig {
       keybindings: mux === null ? {} : normalizeKeybindings(mux['keybindings']),
       ui: mux === null ? DEFAULT_HARNESS_CONFIG.mux.ui : normalizeMuxUiConfig(mux['ui']),
       git: mux === null ? DEFAULT_HARNESS_CONFIG.mux.git : normalizeMuxGitConfig(mux['git']),
+      openIn:
+        mux === null ? DEFAULT_HARNESS_CONFIG.mux.openIn : normalizeMuxOpenInConfig(mux['openIn']),
     },
     github,
+    gateway,
+    linear,
     debug,
     codex,
     claude,
     cursor,
     critique,
+    storage,
     hooks: {
       lifecycle: hooks,
     },
@@ -1435,14 +1764,24 @@ export function resolveHarnessConfigDirectory(
   env: NodeJS.ProcessEnv = process.env,
 ): string {
   const xdgConfigHome = readNonEmptyEnvPath(env.XDG_CONFIG_HOME);
+  const homeDirectory = readNonEmptyEnvPath(env.HOME) ?? readNonEmptyEnvPath(homedir());
+  return resolveHarnessConfigDirectoryFromRoots(cwd, xdgConfigHome, homeDirectory);
+}
+
+export function resolveHarnessConfigDirectoryFromRoots(
+  cwd: string,
+  xdgConfigHome: string | null,
+  homeDirectory: string | null,
+): string {
   if (xdgConfigHome !== null) {
     return resolve(xdgConfigHome, HARNESS_CONFIG_XDG_DIRECTORY_NAME);
   }
-  const homeDirectory = readNonEmptyEnvPath(env.HOME);
   if (homeDirectory !== null) {
     return resolve(homeDirectory, HARNESS_CONFIG_HOME_DIRECTORY_NAME);
   }
-  return resolve(cwd, HARNESS_CONFIG_HOME_DIRECTORY_NAME);
+  throw new Error(
+    `unable to resolve harness config directory: HOME and XDG_CONFIG_HOME are unset (cwd=${cwd})`,
+  );
 }
 
 export function resolveHarnessConfigPath(
@@ -1544,6 +1883,9 @@ export function updateHarnessMuxUiConfig(
     paneWidthPercent: number | null;
     repositoriesCollapsed: boolean;
     shortcutsCollapsed: boolean;
+    startupPane: HarnessMuxStartupPane;
+    showTasks: boolean;
+    showDebugBar: boolean;
   }>,
   options?: {
     cwd?: string;
@@ -1562,14 +1904,20 @@ export function updateHarnessMuxUiConfig(
         update.paneWidthPercent === undefined
           ? current.mux.ui.paneWidthPercent
           : normalizePaneWidthPercent(update.paneWidthPercent, null);
-      const nextShortcutsCollapsed =
-        update.shortcutsCollapsed === undefined
-          ? current.mux.ui.shortcutsCollapsed
-          : update.shortcutsCollapsed;
       const nextRepositoriesCollapsed =
         update.repositoriesCollapsed === undefined
           ? current.mux.ui.repositoriesCollapsed
           : update.repositoriesCollapsed;
+      const nextShortcutsCollapsed =
+        update.shortcutsCollapsed === undefined
+          ? current.mux.ui.shortcutsCollapsed
+          : update.shortcutsCollapsed;
+      const nextStartupPane =
+        update.startupPane === undefined ? current.mux.ui.startupPane : update.startupPane;
+      const nextShowTasks =
+        update.showTasks === undefined ? current.mux.ui.showTasks : update.showTasks;
+      const nextShowDebugBar =
+        update.showDebugBar === undefined ? current.mux.ui.showDebugBar : update.showDebugBar;
       return {
         ...current,
         mux: {
@@ -1579,6 +1927,9 @@ export function updateHarnessMuxUiConfig(
               nextPaneWidthPercent === null ? null : roundUiPercent(nextPaneWidthPercent),
             repositoriesCollapsed: nextRepositoriesCollapsed,
             shortcutsCollapsed: nextShortcutsCollapsed,
+            startupPane: nextStartupPane,
+            showTasks: nextShowTasks,
+            showDebugBar: nextShowDebugBar,
             theme: current.mux.ui.theme,
           },
         },

package/src/config/harness-paths.ts

@@ -39,11 +39,7 @@ export function resolveHarnessWorkspaceDirectory(
   invocationDirectory: string,
   env: NodeJS.ProcessEnv = process.env,
 ): string {
-  const legacyWorkspaceDirectory = resolveLegacyHarnessDirectory(invocationDirectory);
   const configDirectory = resolveHarnessConfigDirectory(invocationDirectory, env);
-  if (resolve(configDirectory) === legacyWorkspaceDirectory) {
-    return legacyWorkspaceDirectory;
-  }
   return resolve(
     configDirectory,
     HARNESS_WORKSPACES_DIRECTORY,
@@ -74,13 +70,14 @@ export function resolveHarnessRuntimePath(
   pathValue: string,
   env: NodeJS.ProcessEnv = process.env,
 ): string {
+  const workspaceRuntimeDirectory = resolveHarnessWorkspaceDirectory(invocationDirectory, env);
   const normalizedPath = pathValue.trim();
   if (normalizedPath.length === 0 || normalizedPath === HARNESS_LEGACY_RELATIVE_ROOT) {
-    return resolveHarnessWorkspaceDirectory(invocationDirectory, env);
+    return workspaceRuntimeDirectory;
   }
   if (normalizedPath.startsWith(`${HARNESS_LEGACY_RELATIVE_ROOT}/`)) {
     return resolve(
-      resolveHarnessWorkspaceDirectory(invocationDirectory, env),
+      workspaceRuntimeDirectory,
       normalizedPath.slice(`${HARNESS_LEGACY_RELATIVE_ROOT}/`.length),
     );
   }
@@ -88,5 +85,5 @@ export function resolveHarnessRuntimePath(
   if (expandedHomePath !== null) {
     return expandedHomePath;
   }
-  return resolve(invocationDirectory, normalizedPath);
+  return resolve(workspaceRuntimeDirectory, normalizedPath);
 }