@phi-code-admin/phi-code 0.74.3 → 0.75.0

package/dist/core/package-manager.js

@@ -2,18 +2,61 @@ import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { homedir, tmpdir } from "node:os";
+function getEnv() {
+    if (process.platform !== "linux" || Object.keys(process.env).length > 0) {
+        return process.env;
+    }
+    try {
+        const data = readFileSync("/proc/self/environ", "utf-8");
+        const env = {};
+        for (const entry of data.split("\0")) {
+            const idx = entry.indexOf("=");
+            if (idx > 0) {
+                env[entry.slice(0, idx)] = entry.slice(idx + 1);
+            }
+        }
+        return env;
+    }
+    catch {
+        return process.env;
+    }
+}
 import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { globSync } from "glob";
 import ignore from "ignore";
 import { minimatch } from "minimatch";
 import { CONFIG_DIR_NAME } from "../config.js";
+import { shouldUseWindowsShell } from "../utils/child-process.js";
 import { parseGitUrl } from "../utils/git.js";
+import { canonicalizePath, isLocalPath } from "../utils/paths.js";
+import { isStdoutTakenOver } from "./output-guard.js";
 const NETWORK_TIMEOUT_MS = 10000;
+const UPDATE_CHECK_CONCURRENCY = 4;
+const GIT_UPDATE_CONCURRENCY = 4;
 function isOfflineModeEnabled() {
     const value = process.env.PI_OFFLINE;
     if (!value)
         return false;
     return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
 }
+/**
+ * Compute a numeric precedence rank for a resource based on its metadata.
+ * Lower rank = higher precedence. Used to sort resolved resources so that
+ * name-collision resolution ("first wins") produces the correct outcome.
+ *
+ * Precedence (highest to lowest):
+ *   0  project + settings entry (source: "local", scope: "project")
+ *   1  project + auto-discovered (source: "auto", scope: "project")
+ *   2  user + settings entry (source: "local", scope: "user")
+ *   3  user + auto-discovered (source: "auto", scope: "user")
+ *   4  package resource (origin: "package")
+ */
+function resourcePrecedenceRank(m) {
+    if (m.origin === "package")
+        return 4;
+    const scopeBase = m.scope === "project" ? 0 : 2;
+    return scopeBase + (m.source === "local" ? 0 : 1);
+}
 const RESOURCE_TYPES = ["extensions", "skills", "prompts", "themes"];
 const FILE_PATTERNS = {
     extensions: /\.(ts|js)$/,
@@ -25,6 +68,9 @@ const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
 function toPosixPath(p) {
     return p.split(sep).join("/");
 }
+function getHomeDir() {
+    return process.env.HOME || homedir();
+}
 function prefixIgnorePattern(line, prefix) {
     const trimmed = line.trim();
     if (!trimmed)
@@ -69,6 +115,12 @@ function addIgnoreRules(ig, dir, rootDir) {
 function isPattern(s) {
     return s.startsWith("!") || s.startsWith("+") || s.startsWith("-") || s.includes("*") || s.includes("?");
 }
+function isOverridePattern(s) {
+    return s.startsWith("!") || s.startsWith("+") || s.startsWith("-");
+}
+function hasGlobPattern(s) {
+    return s.includes("*") || s.includes("?");
+}
 function splitPatterns(entries) {
     const plain = [];
     const patterns = [];
@@ -126,7 +178,7 @@ function collectFiles(dir, filePattern, skipNodeModules = true, ignoreMatcher, r
     }
     return files;
 }
-function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDir) {
+function collectSkillEntries(dir, mode, ignoreMatcher, rootDir) {
     const entries = [];
     if (!existsSync(dir))
         return entries;
@@ -135,6 +187,26 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
     addIgnoreRules(ig, dir, root);
     try {
         const dirEntries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of dirEntries) {
+            if (entry.name !== "SKILL.md") {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    isFile = statSync(fullPath).isFile();
+                }
+                catch {
+                    continue;
+                }
+            }
+            const relPath = toPosixPath(relative(root, fullPath));
+            if (isFile && !ig.ignores(relPath)) {
+                entries.push(fullPath);
+                return entries;
+            }
+        }
         for (const entry of dirEntries) {
             if (entry.name.startsWith("."))
                 continue;
@@ -154,19 +226,15 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
                 }
             }
             const relPath = toPosixPath(relative(root, fullPath));
-            const ignorePath = isDir ? `${relPath}/` : relPath;
-            if (ig.ignores(ignorePath))
+            if (mode === "pi" && dir === root && isFile && entry.name.endsWith(".md") && !ig.ignores(relPath)) {
+                entries.push(fullPath);
                 continue;
-            if (isDir) {
-                entries.push(...collectSkillEntries(fullPath, false, ig, root));
-            }
-            else if (isFile) {
-                const isRootMd = includeRootFiles && entry.name.endsWith(".md");
-                const isSkillMd = !includeRootFiles && entry.name === "SKILL.md";
-                if (isRootMd || isSkillMd) {
-                    entries.push(fullPath);
-                }
             }
+            if (!isDir)
+                continue;
+            if (ig.ignores(`${relPath}/`))
+                continue;
+            entries.push(...collectSkillEntries(fullPath, mode, ig, root));
         }
     }
     catch {
@@ -174,8 +242,8 @@ function collectSkillEntries(dir, includeRootFiles = true, ignoreMatcher, rootDi
     }
     return entries;
 }
-function collectAutoSkillEntries(dir, includeRootFiles = true) {
-    return collectSkillEntries(dir, includeRootFiles);
+function collectAutoSkillEntries(dir, mode) {
+    return collectSkillEntries(dir, mode);
 }
 function findGitRepoRoot(startDir) {
     let dir = resolve(startDir);
@@ -375,7 +443,7 @@ function collectAutoExtensionEntries(dir) {
  */
 function collectResourceFiles(dir, resourceType) {
     if (resourceType === "skills") {
-        return collectSkillEntries(dir);
+        return collectSkillEntries(dir, "pi");
     }
     if (resourceType === "extensions") {
         return collectAutoExtensionEntries(dir);
@@ -383,43 +451,50 @@ function collectResourceFiles(dir, resourceType) {
     return collectFiles(dir, FILE_PATTERNS[resourceType]);
 }
 function matchesAnyPattern(filePath, patterns, baseDir) {
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
     const parentName = isSkillFile ? basename(parentDir) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
-        if (minimatch(rel, pattern) || minimatch(name, pattern) || minimatch(filePath, pattern)) {
+        const normalizedPattern = toPosixPath(pattern);
+        if (minimatch(rel, normalizedPattern) ||
+            minimatch(name, normalizedPattern) ||
+            minimatch(filePathPosix, normalizedPattern)) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return minimatch(parentRel, pattern) || minimatch(parentName, pattern) || minimatch(parentDir, pattern);
+        return (minimatch(parentRel, normalizedPattern) ||
+            minimatch(parentName, normalizedPattern) ||
+            minimatch(parentDirPosix, normalizedPattern));
     });
 }
 function normalizeExactPattern(pattern) {
-    if (pattern.startsWith("./") || pattern.startsWith(".\\")) {
-        return pattern.slice(2);
-    }
-    return pattern;
+    const normalized = pattern.startsWith("./") || pattern.startsWith(".\\") ? pattern.slice(2) : pattern;
+    return toPosixPath(normalized);
 }
 function matchesAnyExactPattern(filePath, patterns, baseDir) {
     if (patterns.length === 0)
         return false;
-    const rel = relative(baseDir, filePath);
+    const rel = toPosixPath(relative(baseDir, filePath));
     const name = basename(filePath);
+    const filePathPosix = toPosixPath(filePath);
     const isSkillFile = name === "SKILL.md";
     const parentDir = isSkillFile ? dirname(filePath) : undefined;
-    const parentRel = isSkillFile ? relative(baseDir, parentDir) : undefined;
+    const parentRel = isSkillFile ? toPosixPath(relative(baseDir, parentDir)) : undefined;
+    const parentDirPosix = isSkillFile ? toPosixPath(parentDir) : undefined;
     return patterns.some((pattern) => {
         const normalized = normalizeExactPattern(pattern);
-        if (normalized === rel || normalized === filePath) {
+        if (normalized === rel || normalized === filePathPosix) {
             return true;
         }
         if (!isSkillFile)
             return false;
-        return normalized === parentRel || normalized === parentDir;
+        return normalized === parentRel || normalized === parentDirPosix;
     });
 }
 function getOverridePatterns(entries) {
@@ -496,6 +571,12 @@ function applyPatterns(allPaths, patterns, baseDir) {
     return new Set(result);
 }
 export class DefaultPackageManager {
+    cwd;
+    agentDir;
+    settingsManager;
+    globalNpmRoot;
+    globalNpmRootCommandKey;
+    progressCallback;
     constructor(options) {
         this.cwd = options.cwd;
         this.agentDir = options.agentDir;
@@ -613,6 +694,30 @@ export class DefaultPackageManager {
         await this.resolvePackageSources(packageSources, accumulator);
         return this.toResolvedPaths(accumulator);
     }
+    listConfiguredPackages() {
+        const globalSettings = this.settingsManager.getGlobalSettings();
+        const projectSettings = this.settingsManager.getProjectSettings();
+        const configuredPackages = [];
+        for (const pkg of globalSettings.packages ?? []) {
+            const source = typeof pkg === "string" ? pkg : pkg.source;
+            configuredPackages.push({
+                source,
+                scope: "user",
+                filtered: typeof pkg === "object",
+                installedPath: this.getInstalledPath(source, "user"),
+            });
+        }
+        for (const pkg of projectSettings.packages ?? []) {
+            const source = typeof pkg === "string" ? pkg : pkg.source;
+            configuredPackages.push({
+                source,
+                scope: "project",
+                filtered: typeof pkg === "object",
+                installedPath: this.getInstalledPath(source, "project"),
+            });
+        }
+        return configuredPackages;
+    }
     async install(source, options) {
         const parsed = this.parseSource(source);
         const scope = options?.local ? "project" : "user";
@@ -635,6 +740,10 @@ export class DefaultPackageManager {
             throw new Error(`Unsupported install source: ${source}`);
         });
     }
+    async installAndPersist(source, options) {
+        await this.install(source, options);
+        this.addSourceToSettings(source, options);
+    }
     async remove(source, options) {
         const parsed = this.parseSource(source);
         const scope = options?.local ? "project" : "user";
@@ -653,44 +762,178 @@ export class DefaultPackageManager {
             throw new Error(`Unsupported remove source: ${source}`);
         });
     }
+    async removeAndPersist(source, options) {
+        await this.remove(source, options);
+        return this.removeSourceFromSettings(source, options);
+    }
     async update(source) {
         const globalSettings = this.settingsManager.getGlobalSettings();
         const projectSettings = this.settingsManager.getProjectSettings();
         const identity = source ? this.getPackageIdentity(source) : undefined;
+        let matched = false;
+        const updateSources = [];
         for (const pkg of globalSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "user") !== identity)
                 continue;
-            await this.updateSourceForScope(sourceStr, "user");
+            matched = true;
+            updateSources.push({ source: sourceStr, scope: "user" });
         }
         for (const pkg of projectSettings.packages ?? []) {
             const sourceStr = typeof pkg === "string" ? pkg : pkg.source;
             if (identity && this.getPackageIdentity(sourceStr, "project") !== identity)
                 continue;
-            await this.updateSourceForScope(sourceStr, "project");
+            matched = true;
+            updateSources.push({ source: sourceStr, scope: "project" });
+        }
+        if (source && !matched) {
+            throw new Error(this.buildNoMatchingPackageMessage(source, [
+                ...(globalSettings.packages ?? []),
+                ...(projectSettings.packages ?? []),
+            ]));
         }
+        await this.updateConfiguredSources(updateSources);
     }
-    async updateSourceForScope(source, scope) {
-        if (isOfflineModeEnabled()) {
+    async updateConfiguredSources(sources) {
+        if (isOfflineModeEnabled() || sources.length === 0) {
             return;
         }
-        const parsed = this.parseSource(source);
-        if (parsed.type === "npm") {
-            if (parsed.pinned)
-                return;
-            await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.installNpm(parsed, scope, false);
-            });
+        const npmCandidates = [];
+        const gitCandidates = [];
+        for (const entry of sources) {
+            const parsed = this.parseSource(entry.source);
+            if (parsed.type === "local" || parsed.pinned) {
+                continue;
+            }
+            if (parsed.type === "npm") {
+                npmCandidates.push({ ...entry, parsed });
+                continue;
+            }
+            gitCandidates.push({ ...entry, parsed });
+        }
+        const npmCheckTasks = npmCandidates.map((entry) => async () => ({
+            entry,
+            shouldUpdate: await this.shouldUpdateNpmSource(entry.parsed, entry.scope),
+        }));
+        const npmCheckResults = await this.runWithConcurrency(npmCheckTasks, UPDATE_CHECK_CONCURRENCY);
+        const userNpmUpdates = [];
+        const projectNpmUpdates = [];
+        for (const result of npmCheckResults) {
+            if (!result.shouldUpdate) {
+                continue;
+            }
+            if (result.entry.scope === "user") {
+                userNpmUpdates.push(result.entry);
+            }
+            else {
+                projectNpmUpdates.push(result.entry);
+            }
+        }
+        const tasks = [];
+        if (userNpmUpdates.length > 0) {
+            tasks.push(this.updateNpmBatch(userNpmUpdates, "user"));
+        }
+        if (projectNpmUpdates.length > 0) {
+            tasks.push(this.updateNpmBatch(projectNpmUpdates, "project"));
+        }
+        if (gitCandidates.length > 0) {
+            const gitTasks = gitCandidates.map((entry) => async () => this.withProgress("update", entry.source, `Updating ${entry.source}...`, async () => {
+                await this.updateGit(entry.parsed, entry.scope);
+            }));
+            tasks.push(this.runWithConcurrency(gitTasks, GIT_UPDATE_CONCURRENCY).then(() => { }));
+        }
+        await Promise.all(tasks);
+    }
+    async shouldUpdateNpmSource(source, scope) {
+        const installedPath = this.getNpmInstallPath(source, scope);
+        const installedVersion = existsSync(installedPath) ? this.getInstalledNpmVersion(installedPath) : undefined;
+        if (!installedVersion) {
+            return true;
+        }
+        try {
+            const latestVersion = await this.getLatestNpmVersion(source.name);
+            return latestVersion !== installedVersion;
+        }
+        catch {
+            // Preserve existing update behavior when version lookup fails.
+            return true;
+        }
+    }
+    async updateNpmBatch(sources, scope) {
+        if (sources.length === 0) {
             return;
         }
-        if (parsed.type === "git") {
-            if (parsed.pinned)
-                return;
-            await this.withProgress("update", source, `Updating ${source}...`, async () => {
-                await this.updateGit(parsed, scope);
-            });
+        const sourceLabel = sources.length === 1 ? sources[0].source : `${scope} npm packages`;
+        const message = sources.length === 1 ? `Updating ${sources[0].source}...` : `Updating ${scope} npm packages...`;
+        const specs = sources.map((entry) => `${entry.parsed.name}@latest`);
+        await this.withProgress("update", sourceLabel, message, async () => {
+            await this.installNpmBatch(specs, scope);
+        });
+    }
+    async installNpmBatch(specs, scope) {
+        if (scope === "user") {
+            await this.runNpmCommand(["install", "-g", ...specs]);
             return;
         }
+        const installRoot = this.getNpmInstallRoot(scope, false);
+        this.ensureNpmProject(installRoot);
+        await this.runNpmCommand(["install", ...specs, "--prefix", installRoot]);
+    }
+    async checkForAvailableUpdates() {
+        if (isOfflineModeEnabled()) {
+            return [];
+        }
+        const globalSettings = this.settingsManager.getGlobalSettings();
+        const projectSettings = this.settingsManager.getProjectSettings();
+        const allPackages = [];
+        for (const pkg of projectSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "project" });
+        }
+        for (const pkg of globalSettings.packages ?? []) {
+            allPackages.push({ pkg, scope: "user" });
+        }
+        const packageSources = this.dedupePackages(allPackages);
+        const checks = packageSources
+            .filter((entry) => entry.scope !== "temporary")
+            .map((entry) => async () => {
+            const source = typeof entry.pkg === "string" ? entry.pkg : entry.pkg.source;
+            const parsed = this.parseSource(source);
+            if (parsed.type === "local" || parsed.pinned) {
+                return undefined;
+            }
+            if (parsed.type === "npm") {
+                const installedPath = this.getNpmInstallPath(parsed, entry.scope);
+                if (!existsSync(installedPath)) {
+                    return undefined;
+                }
+                const hasUpdate = await this.npmHasAvailableUpdate(parsed, installedPath);
+                if (!hasUpdate) {
+                    return undefined;
+                }
+                return {
+                    source,
+                    displayName: parsed.name,
+                    type: "npm",
+                    scope: entry.scope,
+                };
+            }
+            const installedPath = this.getGitInstallPath(parsed, entry.scope);
+            if (!existsSync(installedPath)) {
+                return undefined;
+            }
+            const hasUpdate = await this.gitHasAvailableUpdate(installedPath);
+            if (!hasUpdate) {
+                return undefined;
+            }
+            return {
+                source,
+                displayName: `${parsed.host}/${parsed.path}`,
+                type: "git",
+                scope: entry.scope,
+            };
+        });
+        const results = await this.runWithConcurrency(checks, UPDATE_CHECK_CONCURRENCY);
+        return results.filter((result) => result !== undefined);
     }
     async resolvePackageSources(sources, accumulator, onMissing) {
         for (const { pkg, scope } of sources) {
@@ -721,7 +964,8 @@ export class DefaultPackageManager {
             };
             if (parsed.type === "npm") {
                 const installedPath = this.getNpmInstallPath(parsed, scope);
-                const needsInstall = !existsSync(installedPath) || (await this.npmNeedsUpdate(parsed, installedPath));
+                const needsInstall = !existsSync(installedPath) ||
+                    (parsed.pinned && !(await this.installedNpmMatchesPinnedVersion(parsed, installedPath)));
                 if (needsInstall) {
                     const installed = await installMissing();
                     if (!installed)
@@ -804,6 +1048,35 @@ export class DefaultPackageManager {
         const baseDir = this.getBaseDirForScope(scope);
         return `local:${this.resolvePathFromBase(parsed.path, baseDir)}`;
     }
+    buildNoMatchingPackageMessage(source, configuredPackages) {
+        const suggestion = this.findSuggestedConfiguredSource(source, configuredPackages);
+        if (!suggestion) {
+            return `No matching package found for ${source}`;
+        }
+        return `No matching package found for ${source}. Did you mean ${suggestion}?`;
+    }
+    findSuggestedConfiguredSource(source, configuredPackages) {
+        const trimmedSource = source.trim();
+        const suggestions = new Set();
+        for (const pkg of configuredPackages) {
+            const sourceStr = this.getPackageSourceString(pkg);
+            const parsed = this.parseSource(sourceStr);
+            if (parsed.type === "npm") {
+                if (trimmedSource === parsed.name || trimmedSource === parsed.spec) {
+                    suggestions.add(sourceStr);
+                }
+                continue;
+            }
+            if (parsed.type === "git") {
+                const shorthand = `${parsed.host}/${parsed.path}`;
+                const shorthandWithRef = parsed.ref ? `${shorthand}@${parsed.ref}` : undefined;
+                if (trimmedSource === shorthand || (shorthandWithRef && trimmedSource === shorthandWithRef)) {
+                    suggestions.add(sourceStr);
+                }
+            }
+        }
+        return suggestions.values().next().value;
+    }
     packageSourcesMatch(existing, inputSource, scope) {
         const left = this.getSourceMatchKeyForSettings(this.getPackageSourceString(existing), scope);
         const right = this.getSourceMatchKeyForInput(inputSource);
@@ -830,14 +1103,7 @@ export class DefaultPackageManager {
                 pinned: Boolean(version),
             };
         }
-        const trimmed = source.trim();
-        const isWindowsAbsolutePath = /^[A-Za-z]:[\\/]|^\\\\/.test(trimmed);
-        const isLocalPathLike = trimmed.startsWith(".") ||
-            trimmed.startsWith("/") ||
-            trimmed === "~" ||
-            trimmed.startsWith("~/") ||
-            isWindowsAbsolutePath;
-        if (isLocalPathLike) {
+        if (isLocalPath(source)) {
             return { type: "local", path: source };
         }
         // Try parsing as git URL
@@ -847,30 +1113,30 @@ export class DefaultPackageManager {
         }
         return { type: "local", path: source };
     }
-    /**
-     * Check if an npm package needs to be updated.
-     * - For unpinned packages: check if registry has a newer version
-     * - For pinned packages: check if installed version matches the pinned version
-     */
-    async npmNeedsUpdate(source, installedPath) {
+    async installedNpmMatchesPinnedVersion(source, installedPath) {
+        const installedVersion = this.getInstalledNpmVersion(installedPath);
+        if (!installedVersion) {
+            return false;
+        }
+        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
+        if (!pinnedVersion) {
+            return true;
+        }
+        return installedVersion === pinnedVersion;
+    }
+    async npmHasAvailableUpdate(source, installedPath) {
         if (isOfflineModeEnabled()) {
             return false;
         }
         const installedVersion = this.getInstalledNpmVersion(installedPath);
-        if (!installedVersion)
-            return true;
-        const { version: pinnedVersion } = this.parseNpmSpec(source.spec);
-        if (pinnedVersion) {
-            // Pinned: check if installed matches pinned (exact match for now)
-            return installedVersion !== pinnedVersion;
+        if (!installedVersion) {
+            return false;
         }
-        // Unpinned: check registry for latest version
         try {
             const latestVersion = await this.getLatestNpmVersion(source.name);
             return latestVersion !== installedVersion;
         }
         catch {
-            // If we can't check registry, assume it's fine
             return false;
         }
     }
@@ -888,13 +1154,151 @@ export class DefaultPackageManager {
         }
     }
     async getLatestNpmVersion(packageName) {
-        const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`, {
-            signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS),
+        const npmCommand = this.getNpmCommand();
+        const stdout = await this.runCommandCapture(npmCommand.command, [...npmCommand.args, "view", packageName, "version", "--json"], { cwd: this.cwd, timeoutMs: NETWORK_TIMEOUT_MS });
+        const raw = stdout.trim();
+        if (!raw)
+            throw new Error("Empty response from npm view");
+        return JSON.parse(raw);
+    }
+    async gitHasAvailableUpdate(installedPath) {
+        if (isOfflineModeEnabled()) {
+            return false;
+        }
+        try {
+            const localHead = await this.runCommandCapture("git", ["rev-parse", "HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const remoteHead = await this.getRemoteGitHead(installedPath);
+            return localHead.trim() !== remoteHead.trim();
+        }
+        catch {
+            return false;
+        }
+    }
+    async getRemoteGitHead(installedPath) {
+        const upstreamRef = await this.getGitUpstreamRef(installedPath);
+        if (upstreamRef) {
+            const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", upstreamRef]);
+            const match = remoteHead.match(/^([0-9a-f]{40})\s+/m);
+            if (match?.[1]) {
+                return match[1];
+            }
+        }
+        const remoteHead = await this.runGitRemoteCommand(installedPath, ["ls-remote", "origin", "HEAD"]);
+        const match = remoteHead.match(/^([0-9a-f]{40})\s+HEAD$/m);
+        if (!match?.[1]) {
+            throw new Error("Failed to determine remote HEAD");
+        }
+        return match[1];
+    }
+    async getLocalGitUpdateTarget(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmedUpstream = upstream.trim();
+            if (!trimmedUpstream.startsWith("origin/")) {
+                throw new Error(`Unsupported upstream remote: ${trimmedUpstream}`);
+            }
+            const branch = trimmedUpstream.slice("origin/".length);
+            if (!branch) {
+                throw new Error("Missing upstream branch name");
+            }
+            const head = await this.runCommandCapture("git", ["rev-parse", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            return {
+                ref: "@{upstream}",
+                head,
+                fetchArgs: [
+                    "fetch",
+                    "--prune",
+                    "--no-tags",
+                    "origin",
+                    `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                ],
+            };
+        }
+        catch {
+            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: installedPath }).catch(() => { });
+            const head = await this.runCommandCapture("git", ["rev-parse", "origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const originHeadRef = await this.runCommandCapture("git", ["symbolic-ref", "refs/remotes/origin/HEAD"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            }).catch(() => "");
+            const branch = originHeadRef.trim().replace(/^refs\/remotes\/origin\//, "");
+            if (branch) {
+                return {
+                    ref: "origin/HEAD",
+                    head,
+                    fetchArgs: [
+                        "fetch",
+                        "--prune",
+                        "--no-tags",
+                        "origin",
+                        `+refs/heads/${branch}:refs/remotes/origin/${branch}`,
+                    ],
+                };
+            }
+            return {
+                ref: "origin/HEAD",
+                head,
+                fetchArgs: ["fetch", "--prune", "--no-tags", "origin", "+HEAD:refs/remotes/origin/HEAD"],
+            };
+        }
+    }
+    async getGitUpstreamRef(installedPath) {
+        try {
+            const upstream = await this.runCommandCapture("git", ["rev-parse", "--abbrev-ref", "@{upstream}"], {
+                cwd: installedPath,
+                timeoutMs: NETWORK_TIMEOUT_MS,
+            });
+            const trimmed = upstream.trim();
+            if (!trimmed.startsWith("origin/")) {
+                return undefined;
+            }
+            const branch = trimmed.slice("origin/".length);
+            return branch ? `refs/heads/${branch}` : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    runGitRemoteCommand(installedPath, args) {
+        return this.runCommandCapture("git", args, {
+            cwd: installedPath,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+            env: {
+                GIT_TERMINAL_PROMPT: "0",
+            },
         });
-        if (!response.ok)
-            throw new Error(`Failed to fetch npm registry: ${response.status}`);
-        const data = (await response.json());
-        return data.version;
+    }
+    async runWithConcurrency(tasks, limit) {
+        if (tasks.length === 0) {
+            return [];
+        }
+        const results = new Array(tasks.length);
+        let nextIndex = 0;
+        const workerCount = Math.max(1, Math.min(limit, tasks.length));
+        const worker = async () => {
+            while (true) {
+                const index = nextIndex;
+                nextIndex += 1;
+                if (index >= tasks.length) {
+                    return;
+                }
+                results[index] = await tasks[index]();
+            }
+        };
+        await Promise.all(Array.from({ length: workerCount }, () => worker()));
+        return results;
     }
     /**
      * Get a unique identity for a package, ignoring version/ref.
@@ -948,25 +1352,51 @@ export class DefaultPackageManager {
         const version = match[2];
         return { name, version };
     }
+    getNpmCommand() {
+        const configuredCommand = this.settingsManager.getNpmCommand();
+        if (!configuredCommand || configuredCommand.length === 0) {
+            return { command: "npm", args: [] };
+        }
+        const [command, ...args] = configuredCommand;
+        if (!command) {
+            throw new Error("Invalid npmCommand: first array entry must be a non-empty command");
+        }
+        return { command, args };
+    }
+    async runNpmCommand(args, options) {
+        const npmCommand = this.getNpmCommand();
+        await this.runCommand(npmCommand.command, [...npmCommand.args, ...args], options);
+    }
+    getGitDependencyInstallArgs() {
+        const configuredCommand = this.settingsManager.getNpmCommand();
+        if (configuredCommand && configuredCommand.length > 0) {
+            return ["install"];
+        }
+        return ["install", "--omit=dev"];
+    }
+    runNpmCommandSync(args) {
+        const npmCommand = this.getNpmCommand();
+        return this.runCommandSync(npmCommand.command, [...npmCommand.args, ...args]);
+    }
     async installNpm(source, scope, temporary) {
         if (scope === "user" && !temporary) {
-            await this.runCommand("npm", ["install", "-g", source.spec]);
+            await this.runNpmCommand(["install", "-g", source.spec]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, temporary);
         this.ensureNpmProject(installRoot);
-        await this.runCommand("npm", ["install", source.spec, "--prefix", installRoot]);
+        await this.runNpmCommand(["install", source.spec, "--prefix", installRoot]);
     }
     async uninstallNpm(source, scope) {
         if (scope === "user") {
-            await this.runCommand("npm", ["uninstall", "-g", source.name]);
+            await this.runNpmCommand(["uninstall", "-g", source.name]);
             return;
         }
         const installRoot = this.getNpmInstallRoot(scope, false);
         if (!existsSync(installRoot)) {
             return;
         }
-        await this.runCommand("npm", ["uninstall", source.name, "--prefix", installRoot]);
+        await this.runNpmCommand(["uninstall", source.name, "--prefix", installRoot]);
     }
     async installGit(source, scope) {
         const targetDir = this.getGitInstallPath(source, scope);
@@ -984,7 +1414,7 @@ export class DefaultPackageManager {
         }
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
         }
     }
     async updateGit(source, scope) {
@@ -993,21 +1423,26 @@ export class DefaultPackageManager {
             await this.installGit(source, scope);
             return;
         }
-        // Fetch latest from remote (handles force-push by getting new history)
-        await this.runCommand("git", ["fetch", "--prune", "origin"], { cwd: targetDir });
-        // Reset to tracking branch. Fall back to origin/HEAD when no upstream is configured.
-        try {
-            await this.runCommand("git", ["reset", "--hard", "@{upstream}"], { cwd: targetDir });
-        }
-        catch {
-            await this.runCommand("git", ["remote", "set-head", "origin", "-a"], { cwd: targetDir }).catch(() => { });
-            await this.runCommand("git", ["reset", "--hard", "origin/HEAD"], { cwd: targetDir });
+        const target = await this.getLocalGitUpdateTarget(targetDir);
+        // Fetch only the ref we will reset to, avoiding unrelated branch/tag noise.
+        await this.runCommand("git", target.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], {
+            cwd: targetDir,
+            timeoutMs: NETWORK_TIMEOUT_MS,
+        });
+        if (localHead.trim() === refreshedTargetHead.trim()) {
+            return;
         }
+        await this.runCommand("git", ["reset", "--hard", target.ref], { cwd: targetDir });
         // Clean untracked files (extensions should be pristine)
         await this.runCommand("git", ["clean", "-fdx"], { cwd: targetDir });
         const packageJsonPath = join(targetDir, "package.json");
         if (existsSync(packageJsonPath)) {
-            await this.runCommand("npm", ["install"], { cwd: targetDir });
+            await this.runNpmCommand(this.getGitDependencyInstallArgs(), { cwd: targetDir });
         }
     }
     async refreshTemporaryGitSource(source, sourceStr) {
@@ -1083,11 +1518,20 @@ export class DefaultPackageManager {
         return join(this.getGlobalNpmRoot(), "..");
     }
     getGlobalNpmRoot() {
-        if (this.globalNpmRoot) {
+        const npmCommand = this.getNpmCommand();
+        const commandKey = [npmCommand.command, ...npmCommand.args].join("\0");
+        if (this.globalNpmRoot && this.globalNpmRootCommandKey === commandKey) {
             return this.globalNpmRoot;
         }
-        const result = this.runCommandSync("npm", ["root", "-g"]);
-        this.globalNpmRoot = result.trim();
+        const isBunPackageManager = npmCommand.command === "bun";
+        if (isBunPackageManager) {
+            const binDir = this.runNpmCommandSync(["pm", "bin", "-g"]).trim();
+            this.globalNpmRoot = join(dirname(binDir), "install", "global", "node_modules");
+        }
+        else {
+            this.globalNpmRoot = this.runNpmCommandSync(["root", "-g"]).trim();
+        }
+        this.globalNpmRootCommandKey = commandKey;
         return this.globalNpmRoot;
     }
     getNpmInstallPath(source, scope) {
@@ -1136,21 +1580,21 @@ export class DefaultPackageManager {
     resolvePath(input) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(this.cwd, trimmed);
     }
     resolvePathFromBase(input, baseDir) {
         const trimmed = input.trim();
         if (trimmed === "~")
-            return homedir();
+            return getHomeDir();
         if (trimmed.startsWith("~/"))
-            return join(homedir(), trimmed.slice(2));
+            return join(getHomeDir(), trimmed.slice(2));
         if (trimmed.startsWith("~"))
-            return join(homedir(), trimmed.slice(1));
+            return join(getHomeDir(), trimmed.slice(1));
         return resolve(baseDir, trimmed);
     }
     collectPackageResources(packageRoot, accumulator, filter, metadata) {
@@ -1231,7 +1675,7 @@ export class DefaultPackageManager {
         const entries = manifest?.[resourceType];
         if (entries && entries.length > 0) {
             const allFiles = this.collectFilesFromManifestEntries(entries, packageRoot, resourceType);
-            const manifestPatterns = entries.filter(isPattern);
+            const manifestPatterns = entries.filter(isOverridePattern);
             const enabledByManifest = manifestPatterns.length > 0 ? applyPatterns(allFiles, manifestPatterns, packageRoot) : new Set(allFiles);
             return { allFiles: Array.from(enabledByManifest), enabledByManifest };
         }
@@ -1260,7 +1704,7 @@ export class DefaultPackageManager {
         if (!entries)
             return;
         const allFiles = this.collectFilesFromManifestEntries(entries, root, resourceType);
-        const patterns = entries.filter(isPattern);
+        const patterns = entries.filter(isOverridePattern);
         const enabledPaths = applyPatterns(allFiles, patterns, root);
         for (const f of allFiles) {
             if (enabledPaths.has(f)) {
@@ -1269,8 +1713,18 @@ export class DefaultPackageManager {
         }
     }
     collectFilesFromManifestEntries(entries, root, resourceType) {
-        const plain = entries.filter((entry) => !isPattern(entry));
-        const resolved = plain.map((entry) => resolve(root, entry));
+        const sourceEntries = entries.filter((entry) => !isOverridePattern(entry));
+        const resolved = sourceEntries.flatMap((entry) => {
+            if (!hasGlobPattern(entry)) {
+                return [resolve(root, entry)];
+            }
+            return globSync(entry, {
+                cwd: root,
+                absolute: true,
+                dot: false,
+                nodir: false,
+            }).map((match) => resolve(match));
+        });
         return this.collectFilesFromPaths(resolved, resourceType);
     }
     resolveLocalEntries(entries, resourceType, target, metadata, baseDir) {
@@ -1324,8 +1778,8 @@ export class DefaultPackageManager {
             prompts: join(projectBaseDir, "prompts"),
             themes: join(projectBaseDir, "themes"),
         };
-        const userAgentsSkillsDir = join(homedir(), ".agents", "skills");
-        const projectAgentsSkillDirs = collectAncestorAgentsSkillDirs(this.cwd);
+        const userAgentsSkillsDir = join(getHomeDir(), ".agents", "skills");
+        const projectAgentsSkillDirs = collectAncestorAgentsSkillDirs(this.cwd).filter((dir) => resolve(dir) !== resolve(userAgentsSkillsDir));
         const addResources = (resourceType, paths, metadata, overrides, baseDir) => {
             const target = this.getTargetMap(accumulator, resourceType);
             for (const path of paths) {
@@ -1333,15 +1787,32 @@ export class DefaultPackageManager {
                 this.addResource(target, path, metadata, enabled);
             }
         };
+        // Project extensions from .pi/
         addResources("extensions", collectAutoExtensionEntries(projectDirs.extensions), projectMetadata, projectOverrides.extensions, projectBaseDir);
-        addResources("skills", [
-            ...collectAutoSkillEntries(projectDirs.skills),
-            ...projectAgentsSkillDirs.flatMap((dir) => collectAutoSkillEntries(dir)),
-        ], projectMetadata, projectOverrides.skills, projectBaseDir);
+        // Project skills from .pi/
+        addResources("skills", collectAutoSkillEntries(projectDirs.skills, "pi"), projectMetadata, projectOverrides.skills, projectBaseDir);
+        // Project skills from .agents/ (each with its own baseDir)
+        for (const agentsSkillsDir of projectAgentsSkillDirs) {
+            const agentsBaseDir = dirname(agentsSkillsDir); // the .agents directory
+            const agentsMetadata = {
+                ...projectMetadata,
+                baseDir: agentsBaseDir,
+            };
+            addResources("skills", collectAutoSkillEntries(agentsSkillsDir, "agents"), agentsMetadata, projectOverrides.skills, agentsBaseDir);
+        }
         addResources("prompts", collectAutoPromptEntries(projectDirs.prompts), projectMetadata, projectOverrides.prompts, projectBaseDir);
         addResources("themes", collectAutoThemeEntries(projectDirs.themes), projectMetadata, projectOverrides.themes, projectBaseDir);
+        // User extensions from ~/.pi/agent/
         addResources("extensions", collectAutoExtensionEntries(userDirs.extensions), userMetadata, userOverrides.extensions, globalBaseDir);
-        addResources("skills", [...collectAutoSkillEntries(userDirs.skills), ...collectAutoSkillEntries(userAgentsSkillsDir)], userMetadata, userOverrides.skills, globalBaseDir);
+        // User skills from ~/.pi/agent/
+        addResources("skills", collectAutoSkillEntries(userDirs.skills, "pi"), userMetadata, userOverrides.skills, globalBaseDir);
+        // User skills from ~/.agents/ (with its own baseDir)
+        const userAgentsBaseDir = dirname(userAgentsSkillsDir);
+        const userAgentsMetadata = {
+            ...userMetadata,
+            baseDir: userAgentsBaseDir,
+        };
+        addResources("skills", collectAutoSkillEntries(userAgentsSkillsDir, "agents"), userAgentsMetadata, userOverrides.skills, userAgentsBaseDir);
         addResources("prompts", collectAutoPromptEntries(userDirs.prompts), userMetadata, userOverrides.prompts, globalBaseDir);
         addResources("themes", collectAutoThemeEntries(userDirs.themes), userMetadata, userOverrides.themes, globalBaseDir);
     }
@@ -1395,27 +1866,88 @@ export class DefaultPackageManager {
         };
     }
     toResolvedPaths(accumulator) {
-        const toResolved = (entries) => {
-            return Array.from(entries.entries()).map(([path, { metadata, enabled }]) => ({
+        const mapToResolved = (entries) => {
+            const resolved = Array.from(entries.entries()).map(([path, { metadata, enabled }]) => ({
                 path,
                 enabled,
                 metadata,
             }));
+            resolved.sort((a, b) => resourcePrecedenceRank(a.metadata) - resourcePrecedenceRank(b.metadata));
+            const seen = new Set();
+            return resolved.filter((entry) => {
+                const canonicalPath = canonicalizePath(entry.path);
+                if (seen.has(canonicalPath))
+                    return false;
+                seen.add(canonicalPath);
+                return true;
+            });
         };
         return {
-            extensions: toResolved(accumulator.extensions),
-            skills: toResolved(accumulator.skills),
-            prompts: toResolved(accumulator.prompts),
-            themes: toResolved(accumulator.themes),
+            extensions: mapToResolved(accumulator.extensions),
+            skills: mapToResolved(accumulator.skills),
+            prompts: mapToResolved(accumulator.prompts),
+            themes: mapToResolved(accumulator.themes),
         };
     }
-    runCommand(command, args, options) {
+    spawnCommand(command, args, options) {
+        return spawn(command, args, {
+            cwd: options?.cwd,
+            stdio: isStdoutTakenOver() ? ["ignore", 2, 2] : "inherit",
+            shell: shouldUseWindowsShell(command),
+            env: getEnv(),
+        });
+    }
+    spawnCaptureCommand(command, args, options) {
+        const baseEnv = getEnv();
+        return spawn(command, args, {
+            cwd: options?.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: shouldUseWindowsShell(command),
+            env: options?.env ? { ...baseEnv, ...options.env } : baseEnv,
+        });
+    }
+    runCommandCapture(command, args, options) {
         return new Promise((resolvePromise, reject) => {
-            const child = spawn(command, args, {
-                cwd: options?.cwd,
-                stdio: "inherit",
-                shell: process.platform === "win32",
+            const child = this.spawnCaptureCommand(command, args, options);
+            let stdout = "";
+            let stderr = "";
+            let timedOut = false;
+            const timeout = typeof options?.timeoutMs === "number"
+                ? setTimeout(() => {
+                    timedOut = true;
+                    child.kill();
+                }, options.timeoutMs)
+                : undefined;
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
             });
+            child.once("error", (error) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                reject(error);
+            });
+            child.once("close", (code, signal) => {
+                if (timeout)
+                    clearTimeout(timeout);
+                if (timedOut) {
+                    reject(new Error(`${command} ${args.join(" ")} timed out after ${options?.timeoutMs}ms`));
+                    return;
+                }
+                if (code === 0) {
+                    resolvePromise(stdout.trim());
+                    return;
+                }
+                const exitStatus = code === null ? `signal ${signal ?? "unknown"}` : `code ${code}`;
+                reject(new Error(`${command} ${args.join(" ")} failed with ${exitStatus}: ${stderr || stdout}`));
+            });
+        });
+    }
+    runCommand(command, args, options) {
+        return new Promise((resolvePromise, reject) => {
+            const child = this.spawnCommand(command, args, options);
             child.on("error", reject);
             child.on("exit", (code) => {
                 if (code === 0) {
@@ -1431,10 +1963,11 @@ export class DefaultPackageManager {
         const result = spawnSync(command, args, {
             stdio: ["ignore", "pipe", "pipe"],
             encoding: "utf-8",
-            shell: process.platform === "win32",
+            shell: shouldUseWindowsShell(command),
+            env: getEnv(),
         });
-        if (result.status !== 0) {
-            throw new Error(`Failed to run ${command} ${args.join(" ")}: ${result.stderr || result.stdout}`);
+        if (result.error || result.status !== 0) {
+            throw new Error(`Failed to run ${command} ${args.join(" ")}: ${result.error?.message || result.stderr || result.stdout}`);
         }
         return (result.stdout || result.stderr || "").trim();
     }