Add path share --all for bulk upload

CHANGELOG.md

@@ -2,6 +2,33 @@
 
 All notable changes to the Toolpath workspace are documented here.
 
+## Bulk share with `path share --all` — 2026-08-26
+
+- **`path-cli`** (0.19.0): `path share --all` uploads every session
+  across the installed harnesses instead of opening the picker.
+  `--project-under <dir>` restricts it to sessions whose project
+  directory is under that subtree (same matching as `p cache sync`);
+  `--harness` narrows to one harness. Before uploading it prints one
+  line per project directory — session count, per-harness breakdown,
+  and the configured remote where a `[[project]]` rule resolves — and
+  asks for confirmation (`--yes` skips the prompt, `--dry-run` stops
+  after the summary). Destinations follow the single-session rules:
+  `--repo` for everything, else each directory's configured remote,
+  else `<you>/pathstash`. Requires login; `--anon` is rejected. Uploads
+  are sequential, failures warn and continue, and the run exits
+  non-zero if any failed. Nothing records what was already shared, so
+  re-running uploads everything again.
+- **`toolpath-claude`** (0.13.1): `ConversationMetadata.cwd` — the
+  working directory the session recorded, captured during the metadata
+  pass. `project_path` is decoded from the directory slug, which is
+  lossy (`_` and `.` come back as `/`); `cwd` is the real path.
+- **`toolpath-pi`** (0.6.2): `SessionMeta.cwd` from the session header,
+  for the same reason — the session-dir name turns every `-` into `/`.
+- **`path-cli`**: `share` (the picker and `--all`) groups, displays,
+  and resolves configured remotes for claude and pi sessions by their
+  recorded cwd rather than the slug-decoded project, so `[[project]]`
+  rules on directories containing `_`, `.`, or `-` match them.
+
 ## toolpath-claude 0.13.0 — 2026-08-23
 
 - **Breaking:** `Conversation.segment_ids` replaces `Conversation.session_ids`.

CLAUDE.md

@@ -93,6 +93,7 @@ cargo run -p path-cli -- p import claude --project . --no-cache | path p render
 # Share an agent session to Pathbase (interactive picker, single-shot)
 cargo run -p path-cli -- share
 cargo run -p path-cli -- share --harness claude --session <session-id> --project /path/to/project
+cargo run -p path-cli -- share --all --project-under ~/work   # bulk upload; --dry-run / --yes
 
 # Resume a Toolpath document into a coding agent (interactive harness picker)
 cargo run -p path-cli -- resume <pathbase-url-or-shorthand-or-file-or-cache-id>
@@ -216,8 +217,8 @@ Format references for the agent on-disk formats live at `docs/agents/formats/` 
 ### CLI behaviors
 
 - Interactive pickers: `p import <provider>` auto-launches a fuzzy picker when TTY and no `--session`. Backend: external `fzf` if present, else the embedded skim picker (`embedded-picker` default feature, `crates/path-cli/src/skim_picker.rs`). Multi-select produces a `Graph`; single-select a `Path`. No usable backend falls back to most-recent (with `--project`) or prints the manual recipe. `p list <provider> --format tsv` is the machine-readable surface; the trailing column carries `first_user_message`.
-- `path share` is the one-shot `p import <harness> | p export pathbase`: probes installed harnesses, aggregates sessions into one picker ranking current-directory sessions first; `--harness`/`--session`/`--project` skip the picker; pathbase flags match `p export pathbase`. When the sync manifest shows the picked session unchanged (`sync::fresh_cache_id`), it uploads the cached doc instead of re-deriving. Uploads carry the same full derivation as local projection — no egress stripping.
-- Share also resolves a **configured share remote** from the session's own directory (the project for path-keyed harnesses, the recorded cwd otherwise — via the doc's `path.base` when no `--project` is in play): `crates/path-cli/src/share_config.rs` checks `~/.toolpath/config.toml` `[[project]]` rules (`dir` subtree match, `~/`-expandable, most specific wins; `remote` = bare `owner/name` or a canonical Pathbase repo web URL `https://<host>/u/<owner>/<name>`, which also carries the server — the URL scheme is the extension point for future backends, unknown schemes rejected). Precedence: `--repo` flag > config > `<you>/pathstash`; `--url` beats a URL remote's embedded server. A resolved remote prints `Sharing to <remote> (<origin>)`; hitting one while logged out errors with a `path auth login` hint (no silent anon fall-through), and explicit `--anon` opts out of the mapping. Both sides of the subtree match are prefix-canonicalized (longest existing ancestor resolved, tail re-appended) so macOS `/var`→`/private/var` and deleted checkouts still match. A repo-tracked `.toolpath.toml` is deliberately **not** consulted — a committed file redirecting other users' uploads needs a first-use consent flow (issue #179).
+- `path share` is the one-shot `p import <harness> | p export pathbase`: probes installed harnesses, aggregates sessions into one picker ranking current-directory sessions first; `--harness`/`--session`/`--project` skip the picker; pathbase flags match `p export pathbase`. When the sync manifest shows the picked session unchanged (`sync::fresh_cache_id`), it uploads the cached doc instead of re-deriving. Uploads carry the same full derivation as local projection — no egress stripping. `share --all` skips the picker and uploads every session in scope (`--project-under` subtree, `--harness`), printing a per-project summary and confirming first; it needs login and keeps no record of prior uploads.
+- Share also resolves a **configured share remote** from the session's own directory (the recorded cwd wherever the provider reports one — claude/pi carry it on `ConversationMetadata.cwd`/`SessionMeta.cwd` because their slug-decoded project paths are lossy; else `--project`; else the doc's `path.base`): `crates/path-cli/src/share_config.rs` checks `~/.toolpath/config.toml` `[[project]]` rules (`dir` subtree match, `~/`-expandable, most specific wins; `remote` = bare `owner/name` or a canonical Pathbase repo web URL `https://<host>/u/<owner>/<name>`, which also carries the server — the URL scheme is the extension point for future backends, unknown schemes rejected). Precedence: `--repo` flag > config > `<you>/pathstash`; `--url` beats a URL remote's embedded server. A resolved remote prints `Sharing to <remote> (<origin>)`; hitting one while logged out errors with a `path auth login` hint (no silent anon fall-through), and explicit `--anon` opts out of the mapping. Both sides of the subtree match are prefix-canonicalized (longest existing ancestor resolved, tail re-appended) so macOS `/var`→`/private/var` and deleted checkouts still match. A repo-tracked `.toolpath.toml` is deliberately **not** consulted — a committed file redirecting other users' uploads needs a first-use consent flow (issue #179).
 - `path resume <input>` is the inverse: accepts a Pathbase URL, `owner/repo/slug` shorthand, local file, or cache id; validates a single agent-bearing `Path`; opens a harness picker (pre-selecting `path.meta.source` when installed; `--harness` skips); projects the session into the harness's on-disk layout under `-C/--cwd` (default: shell cwd) and `execvp`'s the harness's resume command (spawn-and-wait on Windows).
 - `path query` plans before it scans: `crates/path-cli/src/query/plan.rs` classifies the jaq filter into `PerFileStream` (element-wise, print as you go), `Decompose` (algebraic aggregation with a derived combine), or `Slurp` (the always-correct whole-array fallback). Recognition is conservative so **the planner never changes an answer**; `query/filter.rs` tests assert streamed output equals slurp byte-for-byte. Execution is parallel (`mod.rs::execute_plan`/`for_each_file`): `PerFileStream`/`Decompose` run the whole per-file pipeline (parse → wrap → filter → render/pack) on rayon workers in chunks — partials cross threads as compact JSON bytes since jaq `Val`s are `Rc`-based — while `Slurp` parallelizes only parse/wrap; output stays byte-identical to a sequential scan (ordering, warnings, error precedence), and the emscripten build stays fully sequential. `TOOLPATH_QUERY_EXPLAIN=1` prints the chosen plan; there is no user-facing flag. Caveat: a streamed top-N matches slurp's ranking, but boundary ties may resolve to different rows.
 

Cargo.toml

@@ -27,7 +27,7 @@ license = "Apache-2.0"
 toolpath = { version = "0.7.1", path = "crates/toolpath" }
 toolpath-convo = { version = "0.11.1", path = "crates/toolpath-convo" }
 toolpath-git = { version = "0.6.0", path = "crates/toolpath-git" }
-toolpath-claude = { version = "0.13.0", path = "crates/toolpath-claude", default-features = false }
+toolpath-claude = { version = "0.13.1", path = "crates/toolpath-claude", default-features = false }
 toolpath-gemini = { version = "0.6.1", path = "crates/toolpath-gemini", default-features = false }
 toolpath-codex = { version = "0.6.1", path = "crates/toolpath-codex" }
 toolpath-copilot = { version = "0.1.0", path = "crates/toolpath-copilot" }
@@ -36,8 +36,8 @@ toolpath-cursor = { version = "0.2.0", path = "crates/toolpath-cursor" }
 toolpath-github = { version = "0.6.0", path = "crates/toolpath-github" }
 toolpath-dot = { version = "0.5.0", path = "crates/toolpath-dot" }
 toolpath-md = { version = "0.7.0", path = "crates/toolpath-md" }
-toolpath-pi = { version = "0.6.1", path = "crates/toolpath-pi" }
-path-cli = { version = "0.18.0", path = "crates/path-cli" }
+toolpath-pi = { version = "0.6.2", path = "crates/toolpath-pi" }
+path-cli = { version = "0.19.0", path = "crates/path-cli" }
 pathbase-client = { version = "0.2.0", path = "crates/pathbase-client" }
 
 reqwest = { version = "0.13", default-features = false, features = ["blocking", "json", "rustls"] }

crates/path-cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "path-cli"
-version = "0.18.0"
+version = "0.19.0"
 edition.workspace = true
 license.workspace = true
 repository = "https://github.com/empathic/toolpath"

crates/path-cli/src/cmd_export.rs

@@ -2033,7 +2033,7 @@ pub(crate) fn run_pathbase_inner(
 /// hash the canonical JSON and use a short hex prefix so re-uploads
 /// of the same content produce the same display label.
 #[cfg(not(target_os = "emscripten"))]
-fn derive_name(doc: &toolpath::v1::Graph) -> String {
+pub(crate) fn derive_name(doc: &toolpath::v1::Graph) -> String {
     let raw = match doc.single_path() {
         Some(p) => p.path.id.as_str(),
         None => doc.graph.id.as_str(),