fix: honor fs when locating skill project roots

docs/core-data-structures/skills.md

@@ -63,7 +63,7 @@ type SkillRegistration = Omit<SkillDefinition, 'disableModelInvocation'> & {
 
 ## Lookup and configuration
 
-Skill lookup is cwd-sensitive because project skill roots are relative to the current workspace. If no git root is found, the supplied cwd itself is the project root.
+Skill lookup is cwd-sensitive because project skill roots are relative to the current workspace. If no git root is found, the supplied cwd itself is the project root. When `ctx.fs` is available, the git-root walk probes `.git` through the filesystem service so remote or sandboxed workspaces do not fall back to the host filesystem boundary.
 
 ```ts type-equiv
 interface SkillLookupOptions {

docs/rfc/implemented/feature/2026-07-05-skill-system.md

@@ -16,7 +16,7 @@ Discovery scans cwd-sensitive project roots, runtime registrations, user roots,
 
 Each skill is either `<name>/SKILL.md` or `<name>.md` with YAML frontmatter. `name` and `description` are required; `whenToUse`, `disableModelInvocation`, and `metadata` are optional. Names are kebab-case. YAML frontmatter is parsed with the `yaml` package instead of `js-yaml` or a hand-written parser: `yaml` is the already-declared modern parser for this package's limited frontmatter needs, and a narrow parser would either reject valid YAML users expect to work or grow into an unreviewed YAML subset.
 
-Skill filesystem I/O goes through `ctx.fs` when a filesystem service is loaded: root discovery uses `listDir`, skill reads use `readText`, and system-skill installation uses `writeText`. The Node filesystem remains a fallback for minimal contexts that mount `dsh-skill` without the fs seam. Missing roots and unreadable or malformed skill files degrade to warn-and-skip so one bad local file does not make every agent request fail.
+Skill filesystem I/O goes through `ctx.fs` when a filesystem service is loaded: project-root lookup probes `.git` with `resolve` and `stat`, root discovery uses `listDir`, skill reads use `readText`, and system-skill installation uses `writeText`. The Node filesystem remains a fallback for minimal contexts that mount `dsh-skill` without the fs seam. Missing roots and unreadable or malformed skill files degrade to warn-and-skip so one bad local file does not make every agent request fail.
 
 The service injects a request-time `## Skills` fragment through the existing `agent/request` waterfall. It appends to `GenerateOptions.system` instead of changing `systemPrompt.assemble()`, because the available project skills depend on the calling agent's cwd. The fragment contains only stable routing metadata and is sorted by skill name after first-wins collection, so equivalent workspaces produce deterministic prompt text and better prefix-cache reuse. Full skill bodies are never included in the listing.
 

packages/core/skill/README.md

@@ -35,9 +35,9 @@ Default roots are resolved in this conflict priority order:
 | Extra | `Config.extraRoots` |
 | System | `~/.dsh/skills/.system` |
 
-The project root is the nearest ancestor containing `.git`; without one, the current cwd is used. The user DSH root skips `.system` during normal user scanning so system skills are read exactly once. Same-name skills keep the highest-priority copy, then model-visible summaries are sorted by skill name for stable prompts and provider prefix-cache friendliness.
+The project root is the nearest ancestor containing `.git`; without one, the current cwd is used. When `ctx.fs` is available, that ancestor lookup probes `.git` through the filesystem service rather than the host filesystem so remote or sandboxed workspaces keep their own project boundary. The user DSH root skips `.system` during normal user scanning so system skills are read exactly once. Same-name skills keep the highest-priority copy, then model-visible summaries are sorted by skill name for stable prompts and provider prefix-cache friendliness.
 
-When `ctx.fs` is available, discovery lists roots through `ctx.fs.listDir`, reads skill files through `ctx.fs.readText`, and installs system skills through `ctx.fs.writeText`. Without a filesystem service, the package falls back to Node filesystem I/O so the service can still run in minimal test contexts. Missing, unreadable, or malformed skill files warn and skip instead of failing the whole request.
+When `ctx.fs` is available, discovery lists roots through `ctx.fs.listDir`, reads skill files through `ctx.fs.readText`, and installs system skills through `ctx.fs.writeText`. Without a filesystem service, the package falls back to Node filesystem I/O for project-root lookup, discovery, reads, and installation so the service can still run in minimal test contexts. Missing, unreadable, or malformed skill files warn and skip instead of failing the whole request.
 
 Discovery is memoized per resolved root set and runtime-skill revision. Runtime `register()` and active disposer calls invalidate the cache; duplicate runtime registrations do not alter the active set. Disk-only changes are picked up on the next invalidation or process restart.
 

packages/core/skill/src/index.ts

@@ -296,7 +296,7 @@ export class SkillService extends Service {
   private async roots(cwd: string | undefined): Promise<{ project: SkillRoot[]; shared: SkillRoot[] }> {
     const project: SkillRoot[] = []
     if (cwd !== undefined) {
-      const projectRoot = await findProjectRoot(resolve(cwd))
+      const projectRoot = await findProjectRoot(resolve(cwd), optionalFileSystem(this.ctx))
       project.push(
         { path: join(projectRoot, '.dsh/skills'), source: 'project-dsh' },
         { path: join(projectRoot, '.agents/skills'), source: 'project-agents' },
@@ -549,14 +549,11 @@ function findClosingFrontmatter(raw: string, start: number): { start: number; bo
   }
 }
 
-async function findProjectRoot(cwd: string): Promise<string> {
+async function findProjectRoot(cwd: string, fs: FileSystem | undefined): Promise<string> {
   let current = cwd
   while (true) {
-    try {
-      await access(join(current, '.git'))
+    if (await pathExists(join(current, '.git'), fs)) {
       return current
-    } catch {
-      // Continue walking upward until a git root is found.
     }
     const parent = dirname(current)
     if (parent === current) return cwd
@@ -564,6 +561,39 @@ async function findProjectRoot(cwd: string): Promise<string> {
   }
 }
 
+async function pathExists(path: string, fs: FileSystem | undefined): Promise<boolean> {
+  if (fs !== undefined) {
+    return await pathExistsInFileSystem(path, fs)
+  }
+  return await pathExistsInNode(path)
+}
+
+async function pathExistsInFileSystem(path: string, fs: FileSystem): Promise<boolean> {
+  let target
+  try {
+    target = await fs.resolve(path)
+  } catch {
+    // A backend may reject or hide this candidate; continue walking upward.
+    return false
+  }
+  try {
+    return await fs.stat(target) !== undefined
+  } catch {
+    // Transient stat failures make only this git-root candidate unusable.
+    return false
+  }
+}
+
+async function pathExistsInNode(path: string): Promise<boolean> {
+  try {
+    await access(path)
+    return true
+  } catch {
+    // Missing host paths are expected while walking toward the filesystem root.
+    return false
+  }
+}
+
 function normalizeSkill(skill: SkillRegistration): SkillDefinition {
   if (!SKILL_NAME.test(skill.name)) throw new Error(`invalid skill name "${skill.name}"`)
   if (skill.description.length === 0) throw new Error(`skill "${skill.name}" requires a description`)

packages/core/skill/tests/skill.spec.ts

@@ -25,6 +25,7 @@ class TestFileSystem extends FileSystem {
   listDirCalls = 0
   failResolvePaths = new Set<string>()
   failStatPaths = new Set<string>()
+  statOverrides = new Map<string, FsInfo | undefined>()
 
   override async resolve(path: string): Promise<FsTarget> {
     if (this.failResolvePaths.has(path)) throw new Error('resolve failed')
@@ -33,6 +34,7 @@ class TestFileSystem extends FileSystem {
 
   override async stat(target: FsTarget): Promise<FsInfo | undefined> {
     if (this.failStatPaths.has(target.displayPath)) throw new Error('stat failed')
+    if (this.statOverrides.has(target.displayPath)) return this.statOverrides.get(target.displayPath)
     try {
       const fs = await import('node:fs/promises')
       const info = await fs.stat(target.displayPath)
@@ -458,6 +460,30 @@ describe('SkillService', () => {
     expect(await ctx.skills.get('binary-skill')).toBeUndefined()
   })
 
+  it('uses the filesystem service when locating a workspace project root', async () => {
+    const home = await tempDir('skill-project-root-fs')
+    const project = await tempDir('skill-project-root-backend')
+    const nestedCwd = join(project, 'packages/app')
+    await mkdir(nestedCwd, { recursive: true })
+    await writeSkill(join(project, '.agents/skills'), 'backend-root', 'Backend root skill')
+
+    const ctx = new Context()
+    await ctx.plugin(TestFileSystem)
+    const fs = ctx.fs as TestFileSystem
+    fs.failResolvePaths.add(join(nestedCwd, '.git'))
+    fs.failStatPaths.add(join(project, 'packages/.git'))
+    fs.statOverrides.set(join(project, '.git'), {
+      version: FsVersion('virtual-git'),
+      type: 'directory',
+      size: 0,
+    })
+    await ctx.plugin(SkillService, { dshHome: join(home, '.dsh'), agentsHome: join(home, '.agents'), installSystemSkills: false })
+
+    expect((await ctx.skills.list({ cwd: nestedCwd })).map(skill => [skill.name, skill.source])).toEqual([
+      ['backend-root', 'project-agents'],
+    ])
+  })
+
   it('degrades when bundled system skill installation fails', async () => {
     const home = await tempDir('skill-install-fail')
     await writeFile(join(home, '.dsh'), 'not a directory')