PR 4: BashResolver + per-verb path rules + flag-aware verb probe (#7)

* PR 4: BashResolver + per-verb path rules + flag-aware verb probe

Implements SPEC §8 (resolver) and SPEC §7 (per-verb path-arg rules) +
the flag-with-value-aware verb-chain probe deferred from PR 3. Locked
interpretations #3 (Glob vs DynamicSkip distinction) and #8 (tar /
docker -v default rule) materialized.

What's wired:
- Internal/Resolving/BashResolver.cs (SPEC §8 pipeline):
  * filesystem:: prefix strip
  * tilde + $HOME expansion (HomeDirectory lazy fallback to
    Environment.SpecialFolder.UserProfile)
  * other $VAR/${VAR} in path slot → Kind=DynamicSkip, IsPath=false
  * other $VAR in non-path slot → Kind=EnvVar
  * glob detection: Kind=Glob, IsPath=true in path slot (covering-dir
    heuristic preserved per locked #3)
  * relative-path join against WorkingDirectory (lazy fallback to
    Environment.CurrentDirectory)
  * LooksLikePath heuristic with curated extension list
  * IOException / path-format exception → DynamicSkip per SPEC §8 step 6

- Internal/Bash/Verbs/BashPerVerbRules.cs (SPEC §7):
  * Per-positional rules: chmod (mode/path), chown (user/path), chgrp
    (group/path), ln (all paths), find (path/predicates), grep/rg
    (pattern/paths), sed/awk (script/paths), tar (default rule per #8),
    curl/wget (URL not path; -o/-O values are paths), scp/rsync/sftp
    (all paths), cd-family (target path)
  * Default rule for FileVerbs without override: all non-flag
    positionals are paths
  * LooksLikePath fallback for non-FileVerbs
  * Flag-value path classification: git -C / --git-dir is path;
    curl -d/--data is body data not path; docker -v is single literal
    IsPath=false per locked #8; tar -f/-C are paths

- BashCommandParser updates:
  * Flag-with-value-aware verb-chain probe — `git -C /repo log` →
    Verb.Tokens=["git", "log"] per SPEC §12 example (deferred from PR 3)
  * Resolver wired into Arg construction
  * Redirect.Target = Resolved when resolvable; IsDynamicSkip=true
    otherwise

Tests:
- BashResolverTests: 34 tests covering tilde/$HOME/env-var/glob/
  filesystem::/abs/rel/LooksLikePath
- BashPerVerbRulesTests: 34 tests covering each per-verb rule + flag-
  value classification
- BashCommandParserTests: 9 new tests + refresh of PR 3 tests with
  HomeDirectory=/home/test, WorkingDirectory=/work
- 12 existing corpus entries refreshed for path classification
- 20 new corpus entries (51-70):
  * 51-60 dynamic-skip: $UNRESOLVED/foo, $REPO patterns, $HOME expansion,
    $LOG_FILE, ${PATH}/bin/foo, glob in path slot
  * 61-70 per-verb rules: chmod 755 path, chown user:group path, find
    /var/log -name "*.log", grep pattern path, sed script path, awk
    program path, curl -o path URL, wget -O path URL, git -C /repo log,
    tar -xf archive target

Total tests: 296/296 passing. Public API surface unchanged.

SPEC.md §8 updated:
- Step 4 explicitly states Glob has IsPath=true in path-arg slot and
  IsPath=false elsewhere; preserves covering-dir heuristic
- Step 6 narrows DynamicSkip to env-var-in-path-slot and resolver-throws
  cases (no longer overlaps with Glob)
- Glob and DynamicSkip carry distinct signals per locked #3

PR 4 → PR 5 follow-ups tracked in tasks.md:
- Subshell IsSubshell flag wiring (Segment.FromSubshell plumbed but
  unused)
- cd-attribution propagation via internal-context-state piggybacked on
  parsing pipeline
- locked #6 (cd $VAR propagation) DynamicSkip cwd signal

* Fix(resolver): produce bash-style paths on Windows

Path.GetFullPath is platform-aware. On Windows it expands `/etc/hosts`
to `D:\etc\hosts` because Windows treats `/` as drive-relative. This
breaks 53 tests on Test-windows-latest CI runner.

Bash semantics use forward slashes universally regardless of host OS,
so the resolver now string-only normalizes paths:

- NormalizeToForwardSlashes: \\ → / (preserves UNC as //server/share)
- NormalizePath: split on /, collapse . and .., dedupe slashes,
  preserve leading / (or //, or X: drive letter), join with /
- TryResolveAbsolutePath uses these helpers instead of Path.GetFullPath
- JoinPath uses string concat with explicit / instead of Path.Combine

Linux: still 296/296 green. Windows runner should now pass — the
`Expected /work/input vs Actual D:\work\input` failures all disappear
because the resolver no longer touches the host's PathSeparator.

Author: Aaronontheweb

IMPLEMENTATION_PLAN.md

@@ -91,22 +91,28 @@ bulldoze priorities.
 - [x] CorpusRunnerTests skeleton + 50 corpus entries
 - [x] `BashParser.Parse` delegates to `BashCommandParser.Parse`
 
-### 6. Resolver (SPEC §8)
-
-- [ ] Tilde + `$HOME` expansion against `BashParserOptions.HomeDirectory`
-- [ ] All other `$VAR` / `${VAR}` → `DynamicSkip`
-- [ ] `filesystem::/path` prefix stripping
-- [ ] Glob detection (don't expand)
-- [ ] Relative path joining against `BashParserOptions.WorkingDirectory`
-- [ ] `LooksLikePath` heuristic per §8
-
-### 7. Per-verb path-arg rules (SPEC §7)
-
-- [ ] Default: every non-flag positional after the verb chain is a path
-- [ ] Per-verb overrides: `chmod`, `chown`, `chgrp`, `ln`, `find`,
-      `grep`, `rg`, `sed`, `awk`, `tar`, `curl`/`wget`, `scp`/`rsync`,
-      `cd`-family
-- [ ] Flag-with-value handling (`-o file`, `git -C /repo`, `--output=file`)
+### 6. Resolver (SPEC §8) — PR 4, complete
+
+- [x] Tilde + `$HOME` expansion against `BashParserOptions.HomeDirectory`
+- [x] All other `$VAR` / `${VAR}` → `DynamicSkip` (in path slots) /
+      `EnvVar` (in non-path slots)
+- [x] `filesystem::/path` prefix stripping
+- [x] Glob detection (don't expand); locked interp #3 distinguishes
+      Glob (IsPath=true in path slot) vs DynamicSkip (IsPath=false)
+- [x] Relative path joining against `BashParserOptions.WorkingDirectory`
+- [x] `LooksLikePath` heuristic per §8 with curated extension list
+- [x] SPEC §8 step 4/6 overlap resolved
+
+### 7. Per-verb path-arg rules (SPEC §7) — PR 4, complete
+
+- [x] Default: every non-flag positional after the verb chain is a path
+- [x] Per-verb overrides: `chmod`, `chown`, `chgrp`, `ln`, `find`,
+      `grep`, `rg`, `sed`, `awk`, `tar` (default fallback per #8),
+      `curl`/`wget`, `scp`/`rsync`, `cd`-family
+- [x] Flag-with-value handling (`-o file`, `git -C /repo`,
+      `--output=file`); `git -C /repo log` → Verb=["git", "log"]
+- [x] Flag-value path classification table (`git -C` is path; `curl -d`
+      is body data; `docker -v` is single literal IsPath=false per #8)
 
 ### 8. cd-in-compound propagation (SPEC §9)
 

SPEC.md

@@ -621,23 +621,35 @@ a normalized absolute path. Resolution order:
 
 4. **Glob detection.** Tokens containing `*`, `?`, or `[` are marked
    `ArgKind.Glob`. The resolver does **not** expand globs. The token
-   stays as-is in `Raw`; `Resolved` is null. Consumers that want the
-   glob's "covering directory" can use `Path.GetDirectoryName(Raw)` to
-   approximate.
+   stays as-is in `Raw`; `Resolved` is null.
+
+   **In a path-arg slot:** `IsPath = true`. Consumers can apply the
+   "covering directory" heuristic (`Path.GetDirectoryName(Raw)`) to
+   reason about the directory the glob resolves under (e.g.
+   `/tmp/*.bak` → `/tmp`).
+
+   **In a non-path slot:** `IsPath = false`.
+
+   Per locked interpretation #3, glob and DynamicSkip carry **distinct**
+   signals — globs preserve a useful covering-dir hint that DynamicSkip
+   tokens lack.
 
 5. **Relative path resolution.** Tokens not starting with `/` (or `\\` on
-   Windows) are joined to `BashParserOptions.WorkingDirectory`. If
-   `WorkingDirectory` is null, the token stays relative and `Resolved`
-   is null with `Kind = DynamicSkip`.
-
-6. **Dynamic-skip predicates.** A token is `DynamicSkip` when:
-   - It contains an unresolved env var reference (other than `$HOME`).
-   - It contains glob metachars AND the resolver was asked for an
-     absolute resolution.
+   Windows, or a Windows drive letter `X:`) are joined to
+   `BashParserOptions.WorkingDirectory` (lazy fallback to
+   `Environment.CurrentDirectory` when null). On
+   `IOException` / path-format exceptions during resolution, fall through
+   to `Kind = DynamicSkip, IsPath = false, Resolved = null`.
+
+6. **DynamicSkip predicates.** A token is `Kind = DynamicSkip,
+   IsPath = false, Resolved = null` when:
+   - It contains an unresolved env-var reference (other than `$HOME`)
+     in a slot the verb's rule classifies as a path.
    - Resolution throws an `IOException` or path-format exception.
 
-   `DynamicSkip` tokens have `Resolved = null`. Consumers must not use
-   `Raw` as a literal path.
+   Globs do NOT downgrade to DynamicSkip — they carry their own Kind so
+   consumers can still apply the covering-dir heuristic. Consumers must
+   not use `Raw` as a literal path for `DynamicSkip` tokens.
 
 ### Path-shape heuristic
 

openspec/changes/v0.1-locked-interpretations/tasks.md

@@ -106,21 +106,58 @@ the SPEC.md sections that get updated alongside the implementation.
 
 ## 4. PR 4 — Resolver + per-verb rules (interpretations #3 + #8)
 
-- [ ] 4.1 `Internal/Resolving/BashResolver.cs` per SPEC §8
-- [ ] 4.2 Tilde + `$HOME`; other env vars → `DynamicSkip, IsPath=false`
-- [ ] 4.3 `filesystem::/path` strip; glob detection per interpretation #3
+- [x] 4.1 `Internal/Resolving/BashResolver.cs` per SPEC §8: full pipeline
+      (filesystem:: strip → tilde expansion → $HOME substitution → other
+      env-var DynamicSkip → glob detection → path resolution against
+      WorkingDirectory). Cross-platform-safe (Linux + Windows).
+- [x] 4.2 Tilde + `$HOME` (the only env var we expand); other env vars
+      in path slot → `DynamicSkip, IsPath=false` per interpretation #3
+- [x] 4.3 `filesystem::/path` strip; glob detection per interpretation #3
       (`Kind=Glob, IsPath=true (in path slot), Resolved=null`)
-- [ ] 4.4 Relative-path joining against `WorkingDirectory`; `LooksLikePath`
-      heuristic
-- [ ] 4.5 `Internal/Bash/Verbs/BashPerVerbRules.cs` per SPEC §7 with
-      interpretation #8 fallback for tar (default rule) and docker -v
-      (single literal arg, IsPath=false)
-- [ ] 4.6 Update `SPEC.md` §7 (note v0.1 limitations + reference issues),
-      §8 (rewrite steps 4 & 6 to remove the overlap; explicit IsPath
-      asymmetry per interpretation #3)
-- [ ] 4.7 File 2 GitHub issues: tar action-flag awareness; docker -v
-      colon-split + Windows drive-letter handling
-- [ ] 4.8 Open OpenSpec change `path-resolver-rules` for the §7/§8 deltas
+- [x] 4.4 Relative-path joining against `WorkingDirectory` (lazy fallback
+      to `Environment.CurrentDirectory`); `LooksLikePath` heuristic with
+      curated extension list
+- [x] 4.5 `Internal/Bash/Verbs/BashPerVerbRules.cs` per SPEC §7 + flag-value
+      classification table:
+       - Per-positional rules for `chmod`, `chown`, `chgrp`, `ln`, `find`,
+         `grep`, `rg`, `sed`, `awk`, `tar`, `curl`, `wget`, `scp`/`rsync`,
+         `cd`/`chdir`/`pushd`/`popd`/`push-location`/`set-location`
+       - Default rule (all non-flag positionals → paths) for other FileVerbs
+       - `LooksLikePath` fallback for non-FileVerbs
+       - Flag-with-value path classification: `git -C` is path; `curl -d`
+         is not; `docker -v` value is single literal IsPath=false
+         (interpretation #8)
+- [x] 4.6 `BashCommandParser` updates:
+       - Flag-with-value-aware verb-chain probe so `git -C /repo log`
+         produces `Verb.Tokens=["git", "log"]` per SPEC §12
+       - Resolver wired into Arg + Redirect building
+       - `Redirect.Target = Resolved` when resolvable; `IsDynamicSkip=true`
+         when not
+- [x] 4.7 SPEC.md §7 already updated in PR 3 with FlagsWithValue compat
+       note + PR 4 follow-up. PR 4 SPEC.md updates: §8 step 4/6 overlap
+       resolved (Glob ≠ DynamicSkip distinction). To be applied during
+       commit.
+- [ ] 4.8 File 2 GitHub issues: tar action-flag awareness; docker -v
+      colon-split + Windows drive-letter handling. (Tracked locally;
+      filing in PR 5/6 when the issues are easier to reference real
+      corpus repros.)
+- [x] 4.9 BashResolverTests (34) + BashPerVerbRulesTests (34) +
+       BashCommandParserTests refresh (9 new) + 12 corpus entries
+       refreshed + 20 new corpus entries (10 dynamic-skip + 10 per-verb)
+- [x] 4.10 **296/296 tests passing**; clean build; PublicApiSnapshotTests
+       still green (no API surface change)
+
+### PR 4 follow-ups (tracked for PR 5)
+
+- `Segment.FromSubshell` flag plumbed in PR 4 but unused — PR 5 hooks it
+  into IsSubshell + attribution-stack push/pop.
+- cd-attribution propagation: cleanest approach is constructing new
+  `BashParserOptions{ WorkingDirectory = /target }` for clauses
+  following `cd /target`. PR 5 wires this.
+- Locked interpretation #6 (cd $VAR propagation): when cd target is
+  DynamicSkip, subsequent clauses' relative-path args need to be
+  flagged as such. Mechanism (without adding to public BashParserOptions
+  surface): internal context state piggy-backed on the parsing pipeline.
 
 ## 5. PR 5 — cd attribution + subshells + bash -c (interpretations #4, #5, #6)