@psnext/slingcli 2.4.20260526-1 → 2.4.20260527-3

package/node_modules/@earendil-works/pi-coding-agent/dist/core/compaction/compaction.js

@@ -154,6 +154,22 @@ export function shouldCompact(contextTokens, contextWindow, settings) {
 // ============================================================================
 // Cut point detection
 // ============================================================================
+const ESTIMATED_IMAGE_CHARS = 4800;
+function estimateTextAndImageContentChars(content) {
+    if (typeof content === "string") {
+        return content.length;
+    }
+    let chars = 0;
+    for (const block of content) {
+        if (block.type === "text" && block.text) {
+            chars += block.text.length;
+        }
+        else if (block.type === "image") {
+            chars += ESTIMATED_IMAGE_CHARS;
+        }
+    }
+    return chars;
+}
 /**
  * Estimate token count for a message using chars/4 heuristic.
  * This is conservative (overestimates tokens).
@@ -162,17 +178,7 @@ export function estimateTokens(message) {
     let chars = 0;
     switch (message.role) {
         case "user": {
-            const content = message.content;
-            if (typeof content === "string") {
-                chars = content.length;
-            }
-            else if (Array.isArray(content)) {
-                for (const block of content) {
-                    if (block.type === "text" && block.text) {
-                        chars += block.text.length;
-                    }
-                }
-            }
+            chars = estimateTextAndImageContentChars(message.content);
             return Math.ceil(chars / 4);
         }
         case "assistant": {
@@ -192,19 +198,7 @@ export function estimateTokens(message) {
         }
         case "custom":
         case "toolResult": {
-            if (typeof message.content === "string") {
-                chars = message.content.length;
-            }
-            else {
-                for (const block of message.content) {
-                    if (block.type === "text" && block.text) {
-                        chars += block.text.length;
-                    }
-                    if (block.type === "image") {
-                        chars += 4800; // Estimate images as 4000 chars, or 1200 tokens
-                    }
-                }
-            }
+            chars = estimateTextAndImageContentChars(message.content);
             return Math.ceil(chars / 4);
         }
         case "bashExecution": {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/export-html/index.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync, writeFileSync } from "fs";
 import { basename, join } from "path";
 import { APP_NAME, getExportTemplateDir } from "../../config.js";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/interactive/theme/theme.js";
+import { normalizePath, resolvePath } from "../../utils/paths.js";
 import { SessionManager } from "../session-manager.js";
 /** Parse a color string to RGB values. Supports hex (#RRGGBB) and rgb(r,g,b) formats. */
 function parseColor(color) {
@@ -187,7 +188,7 @@ export async function exportSessionToHtml(sm, state, options) {
         renderedTools,
     };
     const html = generateHtml(sessionData, opts.themeName);
-    let outputPath = opts.outputPath;
+    let outputPath = opts.outputPath ? normalizePath(opts.outputPath) : undefined;
     if (!outputPath) {
         const sessionBasename = basename(sessionFile, ".jsonl");
         outputPath = `${APP_NAME}-session-${sessionBasename}.html`;
@@ -201,10 +202,11 @@ export async function exportSessionToHtml(sm, state, options) {
  */
 export async function exportFromFile(inputPath, options) {
     const opts = typeof options === "string" ? { outputPath: options } : options || {};
-    if (!existsSync(inputPath)) {
-        throw new Error(`File not found: ${inputPath}`);
+    const resolvedInputPath = resolvePath(inputPath);
+    if (!existsSync(resolvedInputPath)) {
+        throw new Error(`File not found: ${resolvedInputPath}`);
     }
-    const sm = SessionManager.open(inputPath);
+    const sm = SessionManager.open(resolvedInputPath);
     const sessionData = {
         header: sm.getHeader(),
         entries: sm.getEntries(),
@@ -213,9 +215,9 @@ export async function exportFromFile(inputPath, options) {
         tools: undefined,
     };
     const html = generateHtml(sessionData, opts.themeName);
-    let outputPath = opts.outputPath;
+    let outputPath = opts.outputPath ? normalizePath(opts.outputPath) : undefined;
     if (!outputPath) {
-        const inputBasename = basename(inputPath, ".jsonl");
+        const inputBasename = basename(resolvedInputPath, ".jsonl");
         outputPath = `${APP_NAME}-session-${inputBasename}.html`;
     }
     writeFileSync(outputPath, html, "utf8");

package/node_modules/@earendil-works/pi-coding-agent/dist/core/export-html/template.js

@@ -605,9 +605,12 @@
       }
 
       function escapeHtml(text) {
-        const div = document.createElement('div');
-        div.textContent = text;
-        return div.innerHTML;
+        return String(text)
+          .replace(/&/g, '&')
+          .replace(/</g, '&lt;')
+          .replace(/>/g, '&gt;')
+          .replace(/"/g, '&quot;')
+          .replace(/'/g, '&#39;');
       }
 
       /**

package/node_modules/@earendil-works/pi-coding-agent/dist/core/extensions/loader.js

@@ -4,7 +4,6 @@
  */
 import * as fs from "node:fs";
 import { createRequire } from "node:module";
-import * as os from "node:os";
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as _bundledPiAgentCore from "@earendil-works/pi-agent-core";
@@ -22,6 +21,7 @@ import { CONFIG_DIR_NAME, getAgentDir, isBunBinary } from "../../config.js";
 // NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
 // avoiding a circular dependency. Extensions can import from @earendil-works/pi-coding-agent.
 import * as _bundledPiCodingAgent from "../../index.js";
+import { resolvePath } from "../../utils/paths.js";
 import { createEventBus } from "../event-bus.js";
 import { execCommand } from "../exec.js";
 import { createSyntheticSourceInfo } from "../source-info.js";
@@ -91,27 +91,6 @@ function getAliases() {
     };
     return _aliases;
 }
-const UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-function normalizeUnicodeSpaces(str) {
-    return str.replace(UNICODE_SPACES, " ");
-}
-function expandPath(p) {
-    const normalized = normalizeUnicodeSpaces(p);
-    if (normalized.startsWith("~/")) {
-        return path.join(os.homedir(), normalized.slice(2));
-    }
-    if (normalized.startsWith("~")) {
-        return path.join(os.homedir(), normalized.slice(1));
-    }
-    return normalized;
-}
-function resolvePath(extPath, cwd) {
-    const expanded = expandPath(extPath);
-    if (path.isAbsolute(expanded)) {
-        return expanded;
-    }
-    return path.resolve(cwd, expanded);
-}
 /**
  * Create a runtime with throwing stubs for action methods.
  * Runner.bindCore() replaces these with real implementations.
@@ -315,7 +294,7 @@ function createExtension(extensionPath, resolvedPath) {
     };
 }
 async function loadExtension(extensionPath, cwd, eventBus, runtime) {
-    const resolvedPath = resolvePath(extensionPath, cwd);
+    const resolvedPath = resolvePath(extensionPath, cwd, { normalizeUnicodeSpaces: true });
     try {
         const factory = await loadExtensionModule(resolvedPath);
         if (!factory) {
@@ -336,7 +315,8 @@ async function loadExtension(extensionPath, cwd, eventBus, runtime) {
  */
 export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime, extensionPath = "<inline>") {
     const extension = createExtension(extensionPath, extensionPath);
-    const api = createExtensionAPI(extension, runtime, cwd, eventBus);
+    const resolvedCwd = resolvePath(cwd);
+    const api = createExtensionAPI(extension, runtime, resolvedCwd, eventBus);
     await factory(api);
     return extension;
 }
@@ -346,10 +326,11 @@ export async function loadExtensionFromFactory(factory, cwd, eventBus, runtime,
 export async function loadExtensions(paths, cwd, eventBus) {
     const extensions = [];
     const errors = [];
+    const resolvedCwd = resolvePath(cwd);
     const resolvedEventBus = eventBus ?? createEventBus();
     const runtime = createExtensionRuntime();
     for (const extPath of paths) {
-        const { extension, error } = await loadExtension(extPath, cwd, resolvedEventBus, runtime);
+        const { extension, error } = await loadExtension(extPath, resolvedCwd, resolvedEventBus, runtime);
         if (error) {
             errors.push({ path: extPath, error });
             continue;
@@ -460,6 +441,8 @@ function discoverExtensionsInDir(dir) {
  * Discover and load extensions from standard locations.
  */
 export async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir = getAgentDir(), eventBus) {
+    const resolvedCwd = resolvePath(cwd);
+    const resolvedAgentDir = resolvePath(agentDir);
     const allPaths = [];
     const seen = new Set();
     const addPaths = (paths) => {
@@ -472,14 +455,14 @@ export async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir =
         }
     };
     // 1. Project-local extensions: cwd/${CONFIG_DIR_NAME}/extensions/
-    const localExtDir = path.join(cwd, CONFIG_DIR_NAME, "extensions");
+    const localExtDir = path.join(resolvedCwd, CONFIG_DIR_NAME, "extensions");
     addPaths(discoverExtensionsInDir(localExtDir));
     // 2. Global extensions: agentDir/extensions/
-    const globalExtDir = path.join(agentDir, "extensions");
+    const globalExtDir = path.join(resolvedAgentDir, "extensions");
     addPaths(discoverExtensionsInDir(globalExtDir));
     // 3. Explicitly configured paths
     for (const p of configuredPaths) {
-        const resolved = resolvePath(p, cwd);
+        const resolved = resolvePath(p, resolvedCwd, { normalizeUnicodeSpaces: true });
         if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
             // Check for package.json with pi manifest or index.ts
             const entries = resolveExtensionEntries(resolved);
@@ -493,6 +476,6 @@ export async function discoverAndLoadExtensions(configuredPaths, cwd, agentDir =
         }
         addPaths([resolved]);
     }
-    return loadExtensions(allPaths, cwd, eventBus);
+    return loadExtensions(allPaths, resolvedCwd, eventBus);
 }
 //# sourceMappingURL=loader.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/model-registry.js

@@ -8,6 +8,7 @@ import { join } from "path";
 import { Type } from "typebox";
 import { Compile } from "typebox/compile";
 import { getAgentDir } from "../config.js";
+import { normalizePath } from "../utils/paths.js";
 import { BUILT_IN_PROVIDER_DISPLAY_NAMES } from "./provider-display-names.js";
 import { clearConfigValueCache, resolveConfigValueOrThrow, resolveConfigValueUncached, resolveHeadersOrThrow, } from "./resolve-config-value.js";
 // Schema for OpenRouter routing preferences
@@ -91,6 +92,9 @@ const OpenAIResponsesCompatSchema = Type.Object({
 const AnthropicMessagesCompatSchema = Type.Object({
     supportsEagerToolInputStreaming: Type.Optional(Type.Boolean()),
     supportsLongCacheRetention: Type.Optional(Type.Boolean()),
+    sendSessionAffinityHeaders: Type.Optional(Type.Boolean()),
+    supportsCacheControlOnTools: Type.Optional(Type.Boolean()),
+    forceAdaptiveThinking: Type.Optional(Type.Boolean()),
 });
 const ProviderCompatSchema = Type.Union([
     OpenAICompletionsCompatSchema,
@@ -242,7 +246,7 @@ export class ModelRegistry {
     modelsJsonPath;
     constructor(authStorage, modelsJsonPath) {
         this.authStorage = authStorage;
-        this.modelsJsonPath = modelsJsonPath;
+        this.modelsJsonPath = modelsJsonPath ? normalizePath(modelsJsonPath) : undefined;
         this.loadModels();
     }
     static create(authStorage, modelsJsonPath = join(getAgentDir(), "models.json")) {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/output-guard.js

@@ -1,4 +1,40 @@
 let stdoutTakeoverState;
+const RAW_STDOUT_RETRY_DELAY_MS = 10;
+let rawStdoutWriteTail = Promise.resolve();
+function getRawStdoutWrite() {
+    if (stdoutTakeoverState) {
+        return stdoutTakeoverState.rawStdoutWrite;
+    }
+    return process.stdout.write.bind(process.stdout);
+}
+async function writeRawStdoutChunk(text) {
+    while (true) {
+        try {
+            await new Promise((resolve, reject) => {
+                try {
+                    getRawStdoutWrite()(text, (error) => {
+                        if (error)
+                            reject(error);
+                        else
+                            resolve();
+                    });
+                }
+                catch (error) {
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            return;
+        }
+        catch (error) {
+            const writeError = error instanceof Error ? error : new Error(String(error));
+            const code = writeError.code;
+            if (code !== "ENOBUFS" && code !== "EAGAIN" && code !== "EWOULDBLOCK") {
+                throw writeError;
+            }
+            await new Promise((resolve) => setTimeout(resolve, RAW_STDOUT_RETRY_DELAY_MS));
+        }
+    }
+}
 export function takeOverStdout() {
     if (stdoutTakeoverState) {
         return;
@@ -29,31 +65,25 @@ export function isStdoutTakenOver() {
     return stdoutTakeoverState !== undefined;
 }
 export function writeRawStdout(text) {
-    if (stdoutTakeoverState) {
-        stdoutTakeoverState.rawStdoutWrite(text);
+    if (text.length === 0) {
         return;
     }
-    process.stdout.write(text);
+    rawStdoutWriteTail = rawStdoutWriteTail.then(() => writeRawStdoutChunk(text));
+    void rawStdoutWriteTail.catch(() => {
+        process.exit(1);
+    });
 }
-export async function flushRawStdout() {
-    if (stdoutTakeoverState) {
-        await new Promise((resolve, reject) => {
-            stdoutTakeoverState?.rawStdoutWrite("", (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-        });
-        return;
+export async function waitForRawStdoutBackpressure() {
+    while (true) {
+        const tail = rawStdoutWriteTail;
+        await tail;
+        if (tail === rawStdoutWriteTail) {
+            return;
+        }
     }
-    await new Promise((resolve, reject) => {
-        process.stdout.write("", (err) => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
+}
+export async function flushRawStdout() {
+    await waitForRawStdoutBackpressure();
+    await writeRawStdoutChunk("");
 }
 //# sourceMappingURL=output-guard.js.map

package/node_modules/@earendil-works/pi-coding-agent/dist/core/package-manager.js

@@ -27,7 +27,7 @@ import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { spawnProcess, spawnProcessSync } from "../utils/child-process.js";
 import { parseGitUrl } from "../utils/git.js";
-import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync } from "../utils/paths.js";
+import { canonicalizePath, isLocalPath, markPathIgnoredByCloudSync, resolvePath } from "../utils/paths.js";
 import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
 const UPDATE_CHECK_CONCURRENCY = 4;
@@ -577,8 +577,8 @@ export class DefaultPackageManager {
     globalNpmRootCommandKey;
     progressCallback;
     constructor(options) {
-        this.cwd = options.cwd;
-        this.agentDir = options.agentDir;
+        this.cwd = resolvePath(options.cwd);
+        this.agentDir = resolvePath(options.agentDir);
         this.settingsManager = options.settingsManager;
     }
     setProgressCallback(callback) {
@@ -589,9 +589,22 @@ export class DefaultPackageManager {
         const currentSettings = scope === "project" ? this.settingsManager.getProjectSettings() : this.settingsManager.getGlobalSettings();
         const currentPackages = currentSettings.packages ?? [];
         const normalizedSource = this.normalizePackageSourceForSettings(source, scope);
-        const exists = currentPackages.some((existing) => this.packageSourcesMatch(existing, source, scope));
-        if (exists) {
-            return false;
+        const matchIndex = currentPackages.findIndex((existing) => this.packageSourcesMatch(existing, source, scope));
+        if (matchIndex !== -1) {
+            const existing = currentPackages[matchIndex];
+            if (this.getPackageSourceString(existing) === normalizedSource) {
+                return false;
+            }
+            const nextPackages = [...currentPackages];
+            nextPackages[matchIndex] =
+                typeof existing === "string" ? normalizedSource : { ...existing, source: normalizedSource };
+            if (scope === "project") {
+                this.settingsManager.setProjectPackages(nextPackages);
+            }
+            else {
+                this.settingsManager.setPackages(nextPackages);
+            }
+            return true;
         }
         const nextPackages = [...currentPackages, normalizedSource];
         if (scope === "project") {
@@ -801,14 +814,16 @@ export class DefaultPackageManager {
         const gitCandidates = [];
         for (const entry of sources) {
             const parsed = this.parseSource(entry.source);
-            if (parsed.type === "local" || parsed.pinned) {
-                continue;
-            }
+            // Pinned npm versions are fixed. Pinned git refs are configured checkout targets,
+            // so include them to reconcile an existing clone when the configured ref changes.
             if (parsed.type === "npm") {
-                npmCandidates.push({ ...entry, parsed });
-                continue;
+                if (!parsed.pinned) {
+                    npmCandidates.push({ ...entry, parsed });
+                }
+            }
+            else if (parsed.type === "git") {
+                gitCandidates.push({ ...entry, parsed });
             }
-            gitCandidates.push({ ...entry, parsed });
         }
         const npmCheckTasks = npmCandidates.map((entry) => async () => ({
             entry,
@@ -1383,13 +1398,25 @@ export class DefaultPackageManager {
     }
     getNpmInstallArgs(specs, installRoot) {
         const packageManagerName = this.getPackageManagerName();
+        // Extension packages run inside pi and resolve pi APIs through loader aliases/virtual modules.
+        // Disable peer dependency resolution for managed installs (npm's --legacy-peer-deps, and
+        // equivalent bun/pnpm settings) so package managers do not install or solve host-provided
+        // @earendil-works/pi-* peers. Stale auto-installed pi peers can otherwise block updates.
         if (packageManagerName === "bun") {
-            return ["install", ...specs, "--cwd", installRoot];
+            return ["install", ...specs, "--cwd", installRoot, "--omit=peer"];
         }
         if (packageManagerName === "pnpm") {
-            return ["install", ...specs, "--prefix", installRoot, "--config.strict-dep-builds=false"];
-        }
-        return ["install", ...specs, "--prefix", installRoot];
+            return [
+                "install",
+                ...specs,
+                "--prefix",
+                installRoot,
+                "--config.auto-install-peers=false",
+                "--config.strict-peer-dependencies=false",
+                "--config.strict-dep-builds=false",
+            ];
+        }
+        return ["install", ...specs, "--prefix", installRoot, "--legacy-peer-deps"];
     }
     async installNpm(source, scope, temporary) {
         const installRoot = this.getNpmInstallRoot(scope, temporary);
@@ -1410,6 +1437,12 @@ export class DefaultPackageManager {
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
         if (existsSync(targetDir)) {
+            if (source.ref) {
+                await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
+                return;
+            }
+            const target = await this.getLocalGitUpdateTarget(targetDir);
+            await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
             return;
         }
         const gitRoot = this.getGitInstallRoot(scope);
@@ -1432,21 +1465,29 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
+        if (source.ref) {
+            await this.ensureGitRef(targetDir, ["fetch", "origin", source.ref], "FETCH_HEAD");
+            return;
+        }
         const target = await this.getLocalGitUpdateTarget(targetDir);
+        await this.ensureGitRef(targetDir, target.fetchArgs, target.ref);
+    }
+    async ensureGitRef(targetDir, fetchArgs, ref) {
         // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
-        await this.runCommand("git", target.fetchArgs, { cwd: targetDir });
+        await this.runCommand("git", fetchArgs, { cwd: targetDir });
         const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        const refreshedTargetHead = await this.runCommandCapture("git", ["rev-parse", target.ref], {
+        const commitRef = `${ref}^{commit}`;
+        const targetHead = await this.runCommandCapture("git", ["rev-parse", commitRef], {
             cwd: targetDir,
             timeoutMs: NETWORK_TIMEOUT_MS,
         });
-        if (localHead.trim() === refreshedTargetHead.trim()) {
+        if (localHead.trim() === targetHead.trim()) {
             return;
         }
-        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
+        await this.runCommand("git", ["reset", "--hard", commitRef], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
@@ -1616,24 +1657,10 @@ export class DefaultPackageManager {
         return this.cwd;
     }
     resolvePath(input) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(this.cwd, trimmed);
+        return resolvePath(input, this.cwd, { homeDir: getHomeDir(), trim: true });
     }
     resolvePathFromBase(input, baseDir) {
-        const trimmed = input.trim();
-        if (trimmed === "~")
-            return getHomeDir();
-        if (trimmed.startsWith("~/"))
-            return join(getHomeDir(), trimmed.slice(2));
-        if (trimmed.startsWith("~"))
-            return join(getHomeDir(), trimmed.slice(1));
-        return resolve(baseDir, trimmed);
+        return resolvePath(input, baseDir, { homeDir: getHomeDir(), trim: true });
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
         if (filter) {

package/node_modules/@earendil-works/pi-coding-agent/dist/core/prompt-templates.js

@@ -1,8 +1,8 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "fs";
-import { homedir } from "os";
-import { basename, dirname, isAbsolute, join, resolve, sep } from "path";
+import { basename, dirname, join, resolve, sep } from "path";
 import { CONFIG_DIR_NAME } from "../config.js";
 import { parseFrontmatter } from "../utils/frontmatter.js";
+import { resolvePath } from "../utils/paths.js";
 import { createSyntheticSourceInfo } from "./source-info.js";
 /**
  * Parse command arguments respecting quoted strings (bash-style)
@@ -146,20 +146,6 @@ function loadTemplatesFromDir(dir, getSourceInfo) {
     }
     return templates;
 }
-function normalizePath(input) {
-    const trimmed = input.trim();
-    if (trimmed === "~")
-        return homedir();
-    if (trimmed.startsWith("~/"))
-        return join(homedir(), trimmed.slice(2));
-    if (trimmed.startsWith("~"))
-        return join(homedir(), trimmed.slice(1));
-    return trimmed;
-}
-function resolvePromptPath(p, cwd) {
-    const normalized = normalizePath(p);
-    return isAbsolute(normalized) ? normalized : resolve(cwd, normalized);
-}
 /**
  * Load all prompt templates from:
  * 1. Global: agentDir/prompts/
@@ -167,12 +153,12 @@ function resolvePromptPath(p, cwd) {
  * 3. Explicit prompt paths
  */
 export function loadPromptTemplates(options) {
-    const resolvedCwd = options.cwd;
-    const resolvedAgentDir = options.agentDir;
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(options.agentDir);
     const promptPaths = options.promptPaths;
     const includeDefaults = options.includeDefaults;
     const templates = [];
-    const globalPromptsDir = options.agentDir ? join(options.agentDir, "prompts") : resolvedAgentDir;
+    const globalPromptsDir = join(resolvedAgentDir, "prompts");
     const projectPromptsDir = resolve(resolvedCwd, CONFIG_DIR_NAME, "prompts");
     const isUnderPath = (target, root) => {
         const normalizedRoot = resolve(root);
@@ -208,7 +194,7 @@ export function loadPromptTemplates(options) {
     }
     // 3. Load explicit prompt paths
     for (const rawPath of promptPaths) {
-        const resolvedPath = resolvePromptPath(rawPath, resolvedCwd);
+        const resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: true });
         if (!existsSync(resolvedPath)) {
             continue;
         }