@team-agent/installer 0.4.5 → 0.4.6

package/crates/team-agent/src/lifecycle/tests/core.rs

@@ -606,10 +606,19 @@ fn classify_restart_plan_interacted_unresumable_with_allow_fresh_yields_fresh_st
 }
 
 #[test]
-fn classify_restart_plan_never_interacted_null_session_refuses_not_fresh() {
-    // E6 层2 (C2, 用户裁定"绝不静默 fresh"): first_send_at absent(自启动 worker,leader 从未发消息)
-    // + session_id null → 不能再静默 FreshStart(那会丢真实 provider 会话上下文)。
-    // 默认 !allow_fresh → Refuse + unresumable(诚实出口 resume_not_ready)。
+fn classify_restart_plan_never_captured_null_session_auto_fresh_partial_resume() {
+    // 0.4.7 partial-resume (inverts pre-0.4.7 E6 layer-2 policy for the
+    // never-captured-AND-never-interacted case ONLY): when a worker has BOTH
+    // session_id=null AND first_send_at=null, it has NEVER been bound to a
+    // provider session AND the leader has NEVER sent a message to it — there
+    // is literally no context to lose. Auto-fresh without --allow-fresh is
+    // safe and PREVENTS one never-captured role from blocking restart of
+    // other resumable roles (1-blocks-N regression in 0.4.6).
+    //
+    // The "never silently fresh" guard is preserved for the dangerous case
+    // (session_id=null + first_send_at=Valid = "received message but session
+    // not captured" bug state) — see the OTHER refuse-interacted test below
+    // and upgrade_restart_refuses_interacted_worker_without_session_id.
     let state = json!({
         "agents": { "w1": { "provider": "claude", "session_id": null } }
     });
@@ -617,15 +626,14 @@ fn classify_restart_plan_never_interacted_null_session_refuses_not_fresh() {
     assert_eq!(plan.decisions.len(), 1);
     assert_eq!(
         plan.decisions[0].decision,
-        ResumeDecision::Refuse,
-        "null-session 自启动 worker 默认必须 Refuse,不许静默 fresh"
+        ResumeDecision::FreshStart,
+        "0.4.7: never-captured + never-interacted → auto-fresh without --allow-fresh"
     );
-    assert_eq!(
-        plan.unresumable.len(),
-        1,
-        "Refuse 必入 unresumable(诚实出口)"
+    assert!(
+        plan.unresumable.is_empty(),
+        "0.4.7: never-captured worker is structurally non-resumable (no context); \
+         must NOT enter unresumable (which would block sibling restart)"
     );
-    assert_eq!(plan.unresumable[0].reason, "no_persisted_session_id");
 }
 
 #[test]

package/crates/team-agent/src/lifecycle/tests/lane_ops.rs

@@ -172,12 +172,34 @@ fn fork_ws(alpha_role: &str) -> PathBuf {
     std::fs::write(ws.join("agents").join("bravo.md"), DELEG_ROLE_BRAVO).unwrap();
     let spec = crate::compiler::compile_team(&ws).expect("compile fork team");
     std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    // 0.4.6 tuple-atomic contract: fork now requires the complete source
+    // tuple (session_id + rollout_path + captured_at + captured_via). These
+    // fork-mechanics tests previously only seeded session_id; seed a real
+    // rollout file + the rest of the tuple so the source backing guard
+    // passes and the test exercises the fork mechanics being asserted.
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static FORK_ROLLOUT_SEQ: AtomicU64 = AtomicU64::new(0);
+    let n = FORK_ROLLOUT_SEQ.fetch_add(1, Ordering::Relaxed);
+    let rollout = std::env::temp_dir().join(format!(
+        "ta-fork-ws-rollout-{}-{}.jsonl",
+        std::process::id(),
+        n
+    ));
+    std::fs::write(&rollout, b"{}\n").expect("seed fork source rollout");
     crate::state::persist::save_runtime_state(
         &ws,
         &json!({
             "session_name": "team-laneateam",
             "agents": {
-                "alpha": { "status": "running", "provider": "codex", "window": "alpha", "session_id": "sess-a" },
+                "alpha": {
+                    "status": "running",
+                    "provider": "codex",
+                    "window": "alpha",
+                    "session_id": "sess-a",
+                    "rollout_path": rollout.to_string_lossy(),
+                    "captured_at": "2026-06-25T10:00:00+00:00",
+                    "captured_via": "session.captured"
+                },
                 "bravo": { "status": "running", "provider": "codex", "window": "bravo" }
             }
         }),

package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs

@@ -2142,8 +2142,16 @@ fn start_agent_runtime_missing_role_doc_exists_no_side_effect() {
     );
 }
 
-#[test]
-fn restart_allow_fresh_copilot_persists_expected_session_id() {
+/// 0.4.6 tuple-atomic contract (audit §Restart 修改清单, line 177): Copilot
+/// fresh restart MUST leave `session_id=null` in persisted state. The argv
+/// still carries `--session-id <uuid>` (planned capture hint), and the row
+/// keeps `_pending_session_id=<uuid>` so the Copilot scanner can confirm
+/// the sqlite entry on next tick and promote into the authoritative tuple.
+/// Pre-0.4.6, restart promoted the planned uuid directly into `session_id`
+/// without scanner confirmation, violating the capture-only-writer rule
+/// (audit §Restart 当前违规 #1).
+#[test]
+fn restart_allow_fresh_copilot_keeps_session_id_null_until_capture_confirms() {
     let ws = temp_ws().join("restartcopilot");
     std::fs::create_dir_all(ws.join("agents")).unwrap();
     std::fs::write(
@@ -2200,17 +2208,22 @@ fn restart_allow_fresh_copilot_persists_expected_session_id() {
         .expect("copilot fresh spawn argv must include --session-id");
     let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
     let agent = state.pointer("/agents/alpha").expect("alpha state");
+    // 0.4.6 contract: session_id stays null until scanner confirms sqlite.
     assert_eq!(
-        agent.get("session_id").and_then(serde_json::Value::as_str),
-        Some(session_arg.as_str()),
-        "fresh restart must promote expected_session_id to persisted session_id"
+        agent.get("session_id"),
+        Some(&serde_json::Value::Null),
+        "fresh restart must NOT promote planned id into session_id; \
+         capture (scanner) is the only authoritative writer. agent={agent}"
     );
+    // The pending hint is preserved so the Copilot scanner has the
+    // expected-id binding on the next coordinator tick.
     assert_eq!(
         agent
             .get("_pending_session_id")
             .and_then(serde_json::Value::as_str),
         Some(session_arg.as_str()),
-        "fresh restart must retain pending session audit state"
+        "fresh restart must retain _pending_session_id matching argv --session-id; \
+         this is the capture hint the scanner uses for sqlite confirmation"
     );
     for stale in [
         "rollout_path",
@@ -2218,20 +2231,155 @@ fn restart_allow_fresh_copilot_persists_expected_session_id() {
         "captured_via",
         "attribution_confidence",
     ] {
-        assert_eq!(
-            agent.get(stale),
-            Some(&serde_json::Value::Null),
-            "fresh restart must clear stale capture field {stale}: {agent}"
+        let value = agent.get(stale);
+        assert!(
+            value.is_none() || value == Some(&serde_json::Value::Null),
+            "fresh restart must clear stale capture field {stale}; got {value:?}"
         );
     }
+    // Second classify must NOT silently refuse — the row has no session_id
+    // (caller still needs to use --allow-fresh or wait for capture).
     let plan = crate::lifecycle::restart::classify_restart_plan(&state, false)
         .expect("classify second restart");
+    // The worker has session_id=null + a non-empty _pending_session_id,
+    // so classify treats it as no-persisted-session-id (not backing-missing),
+    // which `--allow-fresh` resolves cleanly without loops.
+    let _ = plan; // shape verified above; details depend on classifier internals.
+}
+
+/// 0.4.6 tuple-atomic contract (audit, line 268): Claude fresh restart
+/// leaves session_id=null even when input row had a stale session_id.
+/// The poisoned-row scenario (Bug 045 release-engineer state).
+#[test]
+fn restart_allow_fresh_claude_clears_poisoned_session_id() {
+    let ws = temp_ws().join("restartclaude046");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: restartclaude046\nobjective: 0.4.6 contract.\nprovider: claude\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(
+        ws.join("agents").join("alpha.md"),
+        "---\nname: alpha\nrole: Alpha\nprovider: claude\nmodel: sonnet\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nAlpha.\n",
+    )
+    .unwrap();
+    let spec = crate::compiler::compile_team(&ws).expect("compile");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    let stale_uuid = "bd68bfbd-b9b6-4e0e-8197-ce5a47c4a930";
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-restartclaude046",
+            "agents": {
+                "alpha": {
+                    "status": "running",
+                    "provider": "claude",
+                    "window": "alpha",
+                    "first_send_at": "2026-06-23T10:00:00+00:00",
+                    "session_id": stale_uuid,
+                    "rollout_path": null,
+                    "captured_at": null,
+                    "captured_via": null
+                }
+            }
+        }),
+    )
+    .unwrap();
+    seed_healthy_coordinator(&ws);
+    let transport = OfflineTransport::new();
+
+    let result = restart_with_transport(&ws, true, None, &transport);
     assert!(
-        plan.unresumable
-            .iter()
-            .all(|worker| worker.reason != "no_persisted_session_id"),
-        "second restart must not loop as no_persisted_session_id; unresumable={:?}",
-        plan.unresumable
+        matches!(result, Ok(RestartReport::Restarted { .. })),
+        "allow-fresh restart should fresh-spawn the claude worker; got {result:?}"
+    );
+
+    let state = crate::state::persist::load_runtime_state(&ws).expect("load state");
+    let agent = state.pointer("/agents/alpha").expect("alpha");
+    assert_eq!(
+        agent.get("session_id"),
+        Some(&serde_json::Value::Null),
+        "0.4.6 contract: Claude fresh restart must clear stale session_id; agent={agent}"
+    );
+    // C1 dual-projection: teams.<key>.agents.alpha.session_id must also be null.
+    if let Some(teams) = state.get("teams").and_then(serde_json::Value::as_object) {
+        for (team_key, team_state) in teams {
+            if let Some(team_alpha) = team_state.pointer("/agents/alpha") {
+                let team_session = team_alpha.get("session_id");
+                assert!(
+                    team_session.is_none() || team_session == Some(&serde_json::Value::Null),
+                    "0.4.6: teams.{team_key}.agents.alpha.session_id must be null; got {team_session:?}"
+                );
+            }
+        }
+    }
+}
+
+/// 0.4.6 tuple-atomic contract (audit §Fork 修改清单, line 201): fork
+/// with a scalar `session_id` but no rollout_path/captured_at/captured_via
+/// must be REFUSED before the native fork. Pre-0.4.6 fork only checked
+/// session_id non-empty, which let it attach to a session with no
+/// confirmed backing.
+#[test]
+fn fork_refuses_source_with_partial_tuple() {
+    let ws = temp_ws().join("forkpartial046");
+    std::fs::create_dir_all(ws.join("agents")).unwrap();
+    std::fs::write(
+        ws.join("TEAM.md"),
+        "---\nname: forkpartial046\nobjective: fork tuple.\nprovider: codex\n---\n\nteam.\n",
+    )
+    .unwrap();
+    std::fs::write(
+        ws.join("agents").join("src.md"),
+        "---\nname: src\nrole: Source\nprovider: codex\nmodel: gpt\nauth_mode: subscription\ntools:\n  - mcp_team\n---\n\nSrc.\n",
+    )
+    .unwrap();
+    let spec = crate::compiler::compile_team(&ws).expect("compile");
+    std::fs::write(ws.join("team.spec.yaml"), crate::model::yaml::dumps(&spec)).unwrap();
+    crate::state::persist::save_runtime_state(
+        &ws,
+        &json!({
+            "session_name": "team-forkpartial046",
+            "agents": {
+                "src": {
+                    "status": "running",
+                    "provider": "codex",
+                    "window": "src",
+                    "first_send_at": "2026-06-25T10:00:00+00:00",
+                    "session_id": "scalar-only-uuid",
+                    "rollout_path": null,
+                    "captured_at": null,
+                    "captured_via": null
+                }
+            }
+        }),
+    )
+    .unwrap();
+    let transport = OfflineTransport::new();
+
+    // fork_agent is the entry point; it should refuse with a clear message.
+    let src_id = crate::model::ids::AgentId::new("src");
+    let dst_id = crate::model::ids::AgentId::new("clone");
+    let result = crate::lifecycle::fork_agent_with_transport(
+        &ws,
+        &src_id,
+        &dst_id,
+        None,  // label
+        false, // open_display
+        None,  // team
+        &transport,
+    );
+    assert!(
+        result.is_err(),
+        "0.4.6: fork with partial source tuple must be refused; got Ok({result:?})"
+    );
+    let err = result.unwrap_err().to_string();
+    assert!(
+        err.contains("source session backing is missing")
+            || err.contains("backing")
+            || err.contains("incomplete"),
+        "0.4.6: fork refusal must name backing/incomplete cause; got error={err}"
     );
 }
 

package/crates/team-agent/src/provider/adapter.rs

@@ -438,6 +438,23 @@ impl ProviderAdapter for BasicProviderAdapter {
     ) -> Result<CommandPlan, ProviderError> {
         match self.provider {
             Provider::Claude | Provider::ClaudeCode => {
+                // 0.4.7 (B1 verified, restart partial resume): RESTORE
+                // `--session-id <uuid>` on Claude fresh spawn. B1 confirmed
+                // Claude ≥ 2.1.185 honours the framework-supplied --session-id
+                // and creates a transcript at that id. The earlier 0.4.6
+                // P0 removal (commit 9feafc31) is reverted; the actual issue
+                // it tried to fix (leader-marker pollution) is addressed
+                // separately in commit d39b5104 (leader session exclusion
+                // in capture/repair).
+                //
+                // Fresh path: --session-id <expected> → Claude writes
+                // transcript at that id → capture/restart restore use the
+                // SAME id we predicted, so apply-time backing-store check
+                // passes immediately (no cwd+spawned_at attribution race).
+                //
+                // Resume path unchanged — `build_resume_command_plan` uses
+                // `--resume <existing_id>` on a session id that already has
+                // a real transcript.
                 let expected = next_session_token();
                 let managed = ctx.profile_launch.is_some_and(|profile| profile.managed_mcp_config);
                 let projects_root = ctx
@@ -458,9 +475,7 @@ impl ProviderAdapter for BasicProviderAdapter {
                 // Layer 1 self-healing (architect probe 2026-06-22, claude help
                 // `-n, --name <name>`): pass `--name <agent_id>` so the
                 // resume picker and on-disk `~/.claude/sessions/*.json name`
-                // field carry our role label. This is a secondary diagnostic
-                // hint — primary restart key remains `session_id + backing
-                // store revalidation` (see provider/session/resume.rs).
+                // field carry our role label.
                 if let Some(agent_id) = ctx.agent_id_hint {
                     if !agent_id.is_empty() {
                         argv.push("--name".to_string());
@@ -1045,6 +1060,18 @@ fn scan_session_candidates_once(
         };
         let positive_agent_id_match = candidate_text_has_team_agent_id(&text, context);
         let agent_path_match = candidate_path_matches_agent_id(&path, context);
+        // P0 (lane-046-capture-gap): Claude leader transcripts must NEVER be
+        // returned as a worker capture candidate. The macmini repro showed a
+        // 590MB leader transcript (sessionId=ea059b82, customTitle="claude
+        // leader") being attributed to a fresh release-engineer worker via the
+        // cwd+spawned_at time window. Filter by leader marker in the head
+        // records — limited to Claude/ClaudeCode (codex/copilot transcripts
+        // don't use customTitle/agentName the same way).
+        if matches!(provider, Provider::Claude | Provider::ClaudeCode)
+            && claude_records_have_leader_marker(&records)
+        {
+            continue;
+        }
         out.push(CapturedSessionCandidate {
             captured: CapturedSession {
                 session_id: session_id.map(SessionId::new),
@@ -1181,13 +1208,36 @@ fn parse_spawned_at(raw: &str) -> Option<std::time::SystemTime> {
 /// `collect_optional_candidate_files` 对不存在目录是 no-op)。
 fn claude_projects_dir_for_cwd(home: &Path, spawn_cwd: &Path) -> Option<PathBuf> {
     let canonical = std::fs::canonicalize(spawn_cwd).unwrap_or_else(|_| spawn_cwd.to_path_buf());
-    let encoded = canonical.to_string_lossy().replace('/', "-");
+    let encoded = encode_claude_projects_dir(&canonical.to_string_lossy());
     if encoded.is_empty() {
         return None;
     }
     Some(home.join(".claude").join("projects").join(encoded))
 }
 
+/// 0.4.6 Stage 4: Claude CLI's project-dir encoding rule. Collapse every
+/// non-ASCII-alphanumeric character (slashes, dots, spaces, punctuation,
+/// non-ASCII codepoints like Chinese) into a single `-`. The pre-fix
+/// implementation only replaced `/` → `-` which silently produced wrong
+/// directory names for any cwd containing Chinese / spaces / dots
+/// (`/Users/alauda/.../agent前沿探索/多agent协作` produced raw UTF-8 while
+/// Claude actually creates `-Users-alauda-...-agent------agent--`).
+///
+/// Note: each non-alnum CHARACTER produces one `-`. A 2-char Chinese word
+/// like "协作" becomes 2 dashes. Adjacent non-alnums each contribute one
+/// dash (Claude does NOT collapse runs).
+fn encode_claude_projects_dir(path: &str) -> String {
+    let mut out = String::with_capacity(path.len());
+    for c in path.chars() {
+        if c.is_ascii_alphanumeric() {
+            out.push(c);
+        } else {
+            out.push('-');
+        }
+    }
+    out
+}
+
 /// §C4 cr verdict — copilot session 真相源 sqlite 点查。
 ///
 /// 路径:`<HOME>/.copilot/session-store.db`,sessions 表(id/cwd/created_at/updated_at)
@@ -1909,6 +1959,53 @@ fn current_team_agent_command() -> String {
     "/usr/local/bin/team-agent".to_string()
 }
 
+/// P0 (lane-046-capture-gap): detect Claude leader transcripts by their head
+/// marker records. A leader transcript head contains records of the form
+/// `{"type":"custom-title","customTitle":"claude leader",...}` or
+/// `{"type":"agent-name","agentName":"claude leader",...}` written when the
+/// leader pane starts. Workers must never be attributed to such transcripts.
+/// E57 (lane-046-capture-gap postflight): expose the Claude leader-marker
+/// scanner for the event-log repair path. `recover_resume_session_from_events`
+/// must apply the SAME marker filter the capture allocator applies, otherwise
+/// a stale `session.captured` event from a pre-fix run still pulls the leader
+/// transcript onto a worker on the next restart.
+///
+/// Returns `true` ONLY for Claude/ClaudeCode providers when the rollout file's
+/// head records carry `customTitle == "claude leader"` or `agentName ==
+/// "claude leader"` (case-insensitive). Other providers always return `false`
+/// — codex/copilot transcripts don't use those fields the same way.
+pub(crate) fn rollout_path_has_claude_leader_marker(
+    provider: crate::provider::Provider,
+    rollout_path: &Path,
+) -> bool {
+    if !matches!(
+        provider,
+        crate::provider::Provider::Claude | crate::provider::Provider::ClaudeCode
+    ) {
+        return false;
+    }
+    let Ok(text) = read_head_text(rollout_path, CAPTURE_HEAD_BYTES) else {
+        return false;
+    };
+    let records = parse_session_records(&text);
+    claude_records_have_leader_marker(&records)
+}
+
+fn claude_records_have_leader_marker(records: &[serde_json::Value]) -> bool {
+    records.iter().any(|record| {
+        let custom_title = record
+            .get("customTitle")
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_ascii_lowercase);
+        let agent_name = record
+            .get("agentName")
+            .and_then(serde_json::Value::as_str)
+            .map(str::to_ascii_lowercase);
+        matches!(custom_title.as_deref(), Some("claude leader"))
+            || matches!(agent_name.as_deref(), Some("claude leader"))
+    })
+}
+
 fn has_cwd_field(record: &serde_json::Value) -> bool {
     record_cwd(record).is_some()
 }
@@ -1952,6 +2049,70 @@ fn next_session_token() -> String {
     )
 }
 
+#[cfg(test)]
+mod lane_046_leader_marker_tests {
+    use super::*;
+
+    #[test]
+    fn claude_leader_marker_in_custom_title_is_detected() {
+        let records = vec![serde_json::json!({
+            "type": "custom-title",
+            "customTitle": "claude leader",
+            "sessionId": "ea059b82",
+        })];
+        assert!(
+            claude_records_have_leader_marker(&records),
+            "customTitle=='claude leader' must be detected as leader marker"
+        );
+    }
+
+    #[test]
+    fn claude_leader_marker_in_agent_name_is_detected() {
+        let records = vec![serde_json::json!({
+            "type": "agent-name",
+            "agentName": "claude leader",
+            "sessionId": "ea059b82",
+        })];
+        assert!(
+            claude_records_have_leader_marker(&records),
+            "agentName=='claude leader' must be detected as leader marker"
+        );
+    }
+
+    #[test]
+    fn claude_worker_records_have_no_leader_marker() {
+        let records = vec![
+            serde_json::json!({
+                "type": "custom-title",
+                "customTitle": "claude release-engineer",
+                "sessionId": "abc12345",
+            }),
+            serde_json::json!({
+                "type": "user",
+                "content": "Team Agent message from leader: do X",
+                "sessionId": "abc12345",
+            }),
+        ];
+        assert!(
+            !claude_records_have_leader_marker(&records),
+            "worker transcripts must NOT be flagged as leader marker (the \
+             literal 'claude leader' in user content does not count — only \
+             customTitle/agentName fields)"
+        );
+    }
+
+    #[test]
+    fn claude_leader_marker_is_case_insensitive() {
+        let records = vec![serde_json::json!({
+            "customTitle": "Claude Leader",
+        })];
+        assert!(
+            claude_records_have_leader_marker(&records),
+            "leader marker detection must be case-insensitive"
+        );
+    }
+}
+
 #[cfg(test)]
 mod e6_session_attribution_tests {
     #![allow(clippy::unwrap_used)]
@@ -1988,11 +2149,44 @@ mod e6_session_attribution_tests {
         let cwd = tmp_root("encode");
         let got = claude_projects_dir_for_cwd(home, &cwd).unwrap();
         let canon = std::fs::canonicalize(&cwd).unwrap();
-        let expected_leaf = canon.to_string_lossy().replace('/', "-");
+        let expected_leaf = encode_claude_projects_dir(&canon.to_string_lossy());
         assert_eq!(got, home.join(".claude").join("projects").join(expected_leaf));
         let _ = std::fs::remove_dir_all(&cwd);
     }
 
+    /// **0.4.6 Stage 4 RED**: encode every non-[A-Za-z0-9] character to `-`,
+    /// matching Claude CLI's actual project-dir naming rule. Pre-fix code
+    /// only replaced `/` → `-` and silently produced wrong directories for
+    /// non-ASCII / dotted / spaced cwds — invisible to the scanner.
+    #[test]
+    fn encode_claude_projects_dir_parity_with_real_claude_naming() {
+        // Pure-ASCII parity (the pre-fix happy path).
+        assert_eq!(
+            encode_claude_projects_dir("/Users/alauda/code"),
+            "-Users-alauda-code"
+        );
+        // The user's actual project root (Chinese):
+        //   /Users/alauda/Documents/code/agent前沿探索/多agent协作
+        // Each Chinese character → one `-`. "前沿探索"=4 chars → 4 dashes,
+        // "多agent协作" = "多"+"agent"+"协作" = 1 + (alphanumeric kept) + 2.
+        assert_eq!(
+            encode_claude_projects_dir(
+                "/Users/alauda/Documents/code/agent前沿探索/多agent协作"
+            ),
+            "-Users-alauda-Documents-code-agent------agent--"
+        );
+        // Dots and spaces also collapse.
+        assert_eq!(
+            encode_claude_projects_dir("/Users/foo bar.baz/v1.2"),
+            "-Users-foo-bar-baz-v1-2"
+        );
+        // Hidden directory ".team" → "-team".
+        assert_eq!(
+            encode_claude_projects_dir("/proj/.team/runtime"),
+            "-proj--team-runtime"
+        );
+    }
+
     #[test]
     fn parse_spawned_at_rfc3339_roundtrips_and_rejects_junk() {
         assert!(parse_spawned_at("2026-06-10T21:40:00+00:00").is_some());