feat(parser): migrate qwenpaw provider

QwenPaw stores rewritten JSON session snapshots under workspace-scoped sessions directories, with a second one-level subdirectory namespace for console sessions. Moving it behind a concrete provider keeps those raw ID shapes explicit while continuing to use the shared file-source mechanics where they fit.

The provider preserves workspace project hints, root and console source lookup, hidden/deeper layout rejection, symlinked workspace discovery, content-hash fingerprinting, and force-replace parse semantics for rewritten session files.

fix(parser): prune qwenpaw source traversal

QwenPaw legacy discovery only walks valid workspace directories, the sessions directory, and one real non-hidden namespace below sessions. The provider migration reused the generic recursive JSONL walker, which preserved emitted source filtering but still allowed traversal and event classification through deeper or symlinked session namespaces.

Add a shared traversal predicate to the JSONL source helper so providers can keep discovery and changed-path classification aligned when their source layouts are narrower than an unbounded recursive scan.

test(parser): opt qwenpaw into provider shadow

QwenPaw now has a concrete facade provider on this branch, so its migration mode should enter shadow comparison instead of remaining legacy-only and additive.

Earlier provider opt-ins stay inherited and later branches own their modes.

Validation: go test -tags "fts5" ./internal/parser -run TestProviderMigrationModes -count=1; go test -tags "fts5" ./internal/parser -count=1; go vet ./...; git diff --check

test(sync): compare qwenpaw shadow parity

QwenPaw is shadow-compared on this branch, so add source-level migration coverage that compares provider observation with ParseQwenPawSession.

The test covers both root session files and console subdirectory session files so the path-derived workspace/session IDs and planned data-version behavior stay visible during review.

Validation: go test -tags "fts5" ./internal/parser ./internal/sync -run 'TestObserveProviderSourceMatchesQwenPawLegacyParser|TestQwenPawProvider|TestParseQwenPaw|TestSyncSingleSession_QwenPaw|TestWriteBatchQwenPaw' -count=1; go test -tags "fts5" ./internal/parser ./internal/sync -count=1; go fmt ./...; go vet ./...; git diff --check; ./custom-gcl run --config .golangci.nilaway.yml ./internal/parser/... ./internal/sync/...

refactor(parser): fold qwenpaw into provider

Move QwenPaw parse and source-lookup ownership onto the concrete
qwenPawProvider and delete the package-level legacy entrypoints
(DiscoverQwenPawSessions, FindQwenPawSourceFile, ParseQwenPawSession)
plus their unexported discovery/traversal helpers.

ParseQwenPawSession becomes the provider parseSession method, and the
rawID resolution from FindQwenPawSourceFile moves onto the provider as
sourceFileForRawID with its traversal guard. The provider's existing
JSONLSourceSet already reproduces workspace/sessions/console discovery,
symlink handling, and hidden-subdir pruning, so the legacy
DiscoverQwenPawSessions free function is dropped entirely.

Route QwenPaw sync classification and processing through the
provider-neutral runtime by removing its legacy engine dispatch: the
classifyOnePath workspace/sessions block, the processFile case arm, and
the processQwenPaw method. The provider's SourcesForChangedPath and
forceReplace-on-parse capability preserve changed-path remapping and the
full-rewrite write semantics the legacy path provided.

Make QwenPaw provider-authoritative in the migration manifest, drop its
AgentDef DiscoverFunc/FindSourceFunc hooks, remove it from the pending
shim scan list, and replace the shadow-baseline test with provider API
coverage plus a guard that the legacy symbols stay gone.

To preserve single-session resync parity, FindSource now resolves a
DB-stored file_path that points outside any configured QWENPAW_DIR by
synthesizing a source from the path's implicit
<root>/<workspace>/sessions/ layout, recovering the workspace as
ProjectHint so a reparse keeps the canonical qwenpaw:<workspace>:<stem>
ID instead of orphaning it under an empty workspace.

fix(parser): thread ctx through qwenpaw source lookups

Author: mariusvniekerk

internal/parser/jsonl_source_set_test.go

@@ -369,6 +369,8 @@ func providerFactoryForDef(def AgentDef) ProviderFactory {
 		return newQClawProviderFactory(def)
 	case AgentQwen:
 		return newQwenProviderFactory(def)
+	case AgentQwenPaw:
+		return newQwenPawProviderFactory(def)
 	case AgentWorkBuddy:
 		return newWorkBuddyProviderFactory(def)
 	case AgentZencoder:

internal/parser/provider.go

@@ -54,7 +54,7 @@ var providerMigrationModes = map[AgentType]ProviderMigrationMode{
 	AgentAntigravityCLI: ProviderMigrationLegacyOnly,
 	AgentVibe:           ProviderMigrationLegacyOnly,
 	AgentZed:            ProviderMigrationLegacyOnly,
-	AgentQwenPaw:        ProviderMigrationLegacyOnly,
+	AgentQwenPaw:        ProviderMigrationProviderAuthoritative,
 	AgentGptme:          ProviderMigrationProviderAuthoritative,
 	AgentShelley:        ProviderMigrationLegacyOnly,
 	AgentAider:          ProviderMigrationLegacyOnly,

internal/parser/provider_migration.go

@@ -57,7 +57,6 @@ var pendingShimProviderFiles = map[string]bool{
 	"opencode_provider.go":             true,
 	"openhands_provider.go":            true,
 	"positron_provider.go":             true,
-	"qwenpaw_provider.go":              true,
 	"shelley_provider.go":              true,
 	"vibe_provider.go":                 true,
 	"visualstudio_copilot_provider.go": true,

internal/parser/provider_shim_scan_test.go

@@ -7,190 +7,12 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
-	"sort"
 	"strings"
 	"time"
 
 	"github.com/tidwall/gjson"
 )
 
-// DiscoverQwenPawSessions walks <root>/<workspace>/sessions/*.json and
-// <root>/<workspace>/sessions/console/*.json. Each QwenPaw runtime
-// hosts multiple agent workspaces (e.g. "default", "fund_manager")
-// and each workspace persists one JSON file per active session under
-// sessions/. Hidden subdirectories (e.g. ".weixin-legacy") and the
-// legacy dialog/*.jsonl layout are skipped.
-func DiscoverQwenPawSessions(root string) []DiscoveredFile {
-	if root == "" {
-		return nil
-	}
-	workspaceEntries, err := os.ReadDir(root)
-	if err != nil {
-		return nil
-	}
-	var files []DiscoveredFile
-	for _, wsEntry := range workspaceEntries {
-		if !isDirOrSymlink(wsEntry, root) {
-			continue
-		}
-		workspace := wsEntry.Name()
-		if !IsValidQwenPawIDPart(workspace) {
-			continue
-		}
-		files = append(files,
-			discoverQwenPawSessionsDir(
-				filepath.Join(root, workspace, "sessions"),
-				workspace,
-			)...,
-		)
-	}
-	sort.Slice(files, func(i, j int) bool {
-		return files[i].Path < files[j].Path
-	})
-	return files
-}
-
-// discoverQwenPawSessionsDir collects *.json from a sessions/ root
-// and one level of non-hidden subdirectories (e.g. console/).
-func discoverQwenPawSessionsDir(
-	sessionsDir, workspace string,
-) []DiscoveredFile {
-	entries, err := os.ReadDir(sessionsDir)
-	if err != nil {
-		return nil
-	}
-	var files []DiscoveredFile
-	for _, entry := range entries {
-		if entry.IsDir() {
-			name := entry.Name()
-			if strings.HasPrefix(name, ".") || !IsValidQwenPawIDPart(name) {
-				continue
-			}
-			subDir := filepath.Join(sessionsDir, name)
-			files = append(files,
-				discoverQwenPawSessionsFiles(subDir, workspace)...,
-			)
-			continue
-		}
-		stem, ok := strings.CutSuffix(entry.Name(), ".json")
-		if !ok || !IsValidQwenPawIDPart(stem) {
-			continue
-		}
-		files = append(files, DiscoveredFile{
-			Path:    filepath.Join(sessionsDir, entry.Name()),
-			Project: workspace,
-			Agent:   AgentQwenPaw,
-		})
-	}
-	return files
-}
-
-// discoverQwenPawSessionsFiles collects *.json from a single
-// directory without recursing further.
-func discoverQwenPawSessionsFiles(
-	dir, workspace string,
-) []DiscoveredFile {
-	entries, err := os.ReadDir(dir)
-	if err != nil {
-		return nil
-	}
-	var files []DiscoveredFile
-	for _, entry := range entries {
-		if entry.IsDir() {
-			continue
-		}
-		stem, ok := strings.CutSuffix(entry.Name(), ".json")
-		if !ok || !IsValidQwenPawIDPart(stem) {
-			continue
-		}
-		files = append(files, DiscoveredFile{
-			Path:    filepath.Join(dir, entry.Name()),
-			Project: workspace,
-			Agent:   AgentQwenPaw,
-		})
-	}
-	return files
-}
-
-// FindQwenPawSourceFile resolves a rawID to a sessions JSON file.
-//
-// Raw ID shapes:
-//
-//   - qwenpaw:<workspace>:<stem>            -> <root>/<workspace>/sessions/<stem>.json
-//   - qwenpaw:<workspace>:<subdir>:<stem>   -> <root>/<workspace>/sessions/<subdir>/<stem>.json
-//
-// The subdir segment disambiguates the sessions/console/ layout
-// from the sessions/ root so two files with the same stem cannot
-// collide.
-//
-// Returns "" when the rawID is malformed, references a traversal
-// component (".", ".."), escapes the resolved sessions directory,
-// or the file does not exist.
-func FindQwenPawSourceFile(root, rawID string) string {
-	if root == "" {
-		return ""
-	}
-	workspace, rest, ok := strings.Cut(rawID, ":")
-	if !ok {
-		return ""
-	}
-	if !IsValidQwenPawIDPart(workspace) {
-		return ""
-	}
-	var candidate string
-	if subdir, stem, found := strings.Cut(rest, ":"); found {
-		if !IsValidQwenPawIDPart(subdir) ||
-			!IsValidQwenPawIDPart(stem) {
-			return ""
-		}
-		candidate = filepath.Join(
-			root, workspace, "sessions", subdir, stem+".json",
-		)
-	} else {
-		if !IsValidQwenPawIDPart(rest) {
-			return ""
-		}
-		candidate = filepath.Join(
-			root, workspace, "sessions", rest+".json",
-		)
-	}
-	if !isUnderQwenPawRoot(root, candidate) {
-		return ""
-	}
-	if _, err := os.Stat(candidate); err == nil {
-		return candidate
-	}
-	return ""
-}
-
-// isUnderQwenPawRoot reports whether candidate resolves to a path
-// inside <root>/<workspace>/sessions/. Both sides are cleaned and
-// converted to absolute form so that "." / ".." segments in the
-// candidate cannot escape the QwenPaw root.
-func isUnderQwenPawRoot(root, candidate string) bool {
-	absRoot, err := filepath.Abs(filepath.Clean(root))
-	if err != nil {
-		return false
-	}
-	absCand, err := filepath.Abs(filepath.Clean(candidate))
-	if err != nil {
-		return false
-	}
-	rel, err := filepath.Rel(absRoot, absCand)
-	if err != nil {
-		return false
-	}
-	rel = filepath.ToSlash(rel)
-	if rel == "." || rel == ".." || strings.HasPrefix(rel, "../") {
-		return false
-	}
-	parts := strings.Split(rel, "/")
-	if len(parts) < 2 || parts[1] != "sessions" {
-		return false
-	}
-	return true
-}
-
 // IsValidQwenPawIDPart accepts workspace names and session file
 // stems. QwenPaw emits channel-scoped filenames containing dots,
 // at-signs, and double dashes (e.g. "<userId>@im.wechat_wechat--..."),
@@ -202,8 +24,8 @@ func isUnderQwenPawRoot(root, candidate string) bool {
 // part is joined into a session ID:
 //
 //   - ":" joins ID parts in qwenpawSessionID. A stem "foo:bar" would
-//     produce qwenpaw:<workspace>:foo:bar, which FindQwenPawSourceFile
-//     reparses as the sessions/foo/bar.json subdir layout.
+//     produce qwenpaw:<workspace>:foo:bar, which source lookup reparses
+//     as the sessions/foo/bar.json subdir layout.
 //   - "~" is the remote-host separator (see StripHostPrefix). A part
 //     containing it would be split off as a bogus host prefix.
 //   - "?", "#", and "%" are URL delimiters. Session IDs are
@@ -261,7 +83,7 @@ func qwenpawSessionID(path, project, stem string) (string, error) {
 	return "qwenpaw:" + project + ":" + parent + ":" + stem, nil
 }
 
-// ParseQwenPawSession parses a QwenPaw sessions/<name>.json file.
+// parseSession parses a QwenPaw sessions/<name>.json file.
 //
 // The on-disk shape is:
 //
@@ -286,7 +108,7 @@ func qwenpawSessionID(path, project, stem string) (string, error) {
 // of Anthropic's user-side tool_result). They map to RoleUser +
 // IsSystem so they remain distinguishable from real user turns
 // without inflating UserMessageCount.
-func ParseQwenPawSession(
+func parseQwenPawSession(
 	path, project, machine string,
 ) (*ParsedSession, []ParsedMessage, error) {
 	raw, err := os.ReadFile(path)