@@ -287,10 +287,12 @@ ccusage antigravity daily
 ccusage zcode daily
 ```
 
-Source-specific settings are also applied when running unified reports such as `ccusage daily`. Each source uses the same merged options as its focused command: global `defaults`, `commands.<report>`, `commands."<source>:<report>"`, `<source>.defaults`, and `<source>.commands.<report>`, with command-line flags taking precedence for every source. Set `offline` and `pricingOverrides` globally to share them across sources, or in a source section to specialize them. Each source groups dates with its resolved timezone before rows are combined, so sources with different timezones can place the same event on adjacent calendar dates.
+Source-specific settings are also applied when running unified reports such as `ccusage daily`. Each source uses the same merged options as its focused command: global `defaults`, `commands.<report>`, `commands."<source>:<report>"`, `<source>.defaults`, and `<source>.commands.<report>`, with command-line flags taking precedence for every source. Set `offline` and `pricingOverrides` globally to share them across sources, or in a source section to specialize them. Set `claude.commands.daily.project` to filter Claude rows in unified daily reports and their sections. Unified weekly reports use the unified command's `startOfWeek` for every source and for `--last` calculation; source-level `startOfWeek` values are ignored. Each source groups dates with its resolved timezone before rows are combined, so sources with different timezones can place the same event on adjacent calendar dates.
 
 Use `pi.stores` for additional pi-format session stores, such as tools or forks that write sessions outside `~/.pi/agent/sessions`. Named stores are additive to the default `pi` agent in unified reports, use their own agent name in JSON and tables, and prefix models with `[name]` followed by a space. Store names must match `^[a-z][a-z0-9_-]{0,31}$`, must be unique, and cannot use a built-in agent name. Each store path can be one sessions directory or a comma-separated list; `~` is expanded for store paths, nonexistent paths are treated as empty, and resolved paths that overlap the default `pi` store or another named store — including one path nested inside another — are rejected. They do not create focused commands such as `ccusage omp daily`; `PI_AGENT_DIR`, `--pi-path`, and `pi.defaults.piPath` still affect only the default `pi` agent.
 
+Named stores use the unified report's options and pricing overrides; `pi.defaults` and `pi.commands` apply only to the default `pi` source.
+
 For a source-focused command, or each source within a unified report, options are applied in this order:
 
 1. `defaults`
 
@@ -170,6 +170,7 @@ fn load_pricing(
     let mut cached = Vec::new();
     let pricing_by_source = BUILT_IN_AGENT_NAMES
         .iter()
+        .filter(|agent| !["claude", "opencode", "qwen"].contains(agent))
         .map(|agent| {
             (
                 *agent,
@@ -235,6 +236,9 @@ fn load_base_rows(
     let codex_speed = sources
         .get("codex")
         .map_or(CodexSpeed::Auto, |source| source.codex_speed);
+    let claude_project = sources
+        .get("claude")
+        .and_then(|source| source.claude_project.as_deref());
     let pi_path = sources
         .get("pi")
         .and_then(|source| source.pi_path.as_deref());
@@ -246,7 +250,9 @@ fn load_base_rows(
             index: 0,
             agent: BUILT_IN_AGENT_NAMES[0],
             progress_agent: crate::progress::UsageLoadAgent("Claude"),
-            load: Box::new(|| load_claude_rows(load_kind, &source_shared["claude"])),
+            load: Box::new(|| {
+                load_claude_rows(load_kind, &source_shared["claude"], claude_project)
+            }),
         },
         AgentLoadSpec {
             index: 1,
@@ -789,9 +795,13 @@ fn filtered_pi_format_agent_rows(
     })
 }
 
-fn load_claude_rows(kind: AgentReportKind, shared: &SharedArgs) -> Result<AgentRows> {
+fn load_claude_rows(
+    kind: AgentReportKind,
+    shared: &SharedArgs,
+    project_filter: Option<&str>,
+) -> Result<AgentRows> {
     if kind == AgentReportKind::Session {
-        let entries = claude::load_entries(shared, None)?;
+        let entries = claude::load_entries(shared, project_filter)?;
         let detected = !entries.is_empty();
         let mut summaries = summarize_entry_sessions(&entries)?;
         filter_session_summaries(&mut summaries, shared);
@@ -804,7 +814,7 @@ fn load_claude_rows(kind: AgentReportKind, shared: &SharedArgs) -> Result<AgentR
     let claude::DailySummaries {
         mut summaries,
         detected,
-    } = claude::load_daily_summaries_with_detection(shared, None, false)?;
+    } = claude::load_daily_summaries_with_detection(shared, project_filter, false)?;
     filter_daily_summaries_by_date(&mut summaries, shared);
     Ok(AgentRows {
         rows: summary_rows("claude", summaries, false),
@@ -1109,6 +1119,89 @@ mod tests {
         summary_rows(agent, vec![summary], false).pop().unwrap()
     }
 
+    #[test]
+    fn pricing_maps_exclude_sources_that_load_their_own_pricing() {
+        let shared = SharedArgs {
+            offline: true,
+            ..SharedArgs::default()
+        };
+        let source_shared = shared_by_source(&BTreeMap::new(), &shared);
+
+        let (pricing_by_source, unified_pricing) = load_pricing(&shared, &source_shared, false);
+
+        for agent in ["claude", "opencode", "qwen"] {
+            assert!(
+                !pricing_by_source.contains_key(agent),
+                "{agent} has its own pricing map"
+            );
+        }
+        for agent in BUILT_IN_AGENT_NAMES {
+            if !["claude", "opencode", "qwen"].contains(agent) {
+                assert!(
+                    pricing_by_source.contains_key(agent),
+                    "{agent} needs a pricing map"
+                );
+            }
+        }
+        assert!(unified_pricing.is_none());
+    }
+
+    #[test]
+    fn source_claude_project_filters_daily_and_session_rows_without_filtering_other_sources() {
+        let fixture = fs_fixture!({
+            "claude-config/projects/project-a/session-a.jsonl": r#"{"timestamp":"2099-01-02T00:00:00.000Z","sessionId":"session-a","costUSD":0.01,"message":{"usage":{"input_tokens":10,"output_tokens":5,"cache_creation_input_tokens":0,"cache_read_input_tokens":0},"model":"claude-sonnet-4-20250514","id":"msg-a"}}"#,
+            "claude-config/projects/project-b/session-b.jsonl": r#"{"timestamp":"2099-01-02T00:00:00.000Z","sessionId":"session-b","costUSD":0.02,"message":{"usage":{"input_tokens":1000,"output_tokens":500,"cache_creation_input_tokens":0,"cache_read_input_tokens":0},"model":"claude-sonnet-4-20250514","id":"msg-b"}}"#,
+            "pi/sessions/project-pi/agent_pi-session.jsonl": r#"{"type":"message","timestamp":"2099-01-02T00:00:00.000Z","message":{"role":"assistant","model":"gpt-5","usage":{"input":7,"output":3}}}"#,
+        });
+        let _environment = isolated_source_environment(&fixture);
+        let shared = SharedArgs {
+            json: true,
+            mode: CostMode::Display,
+            offline: true,
+            timezone: Some("UTC".to_string()),
+            ..SharedArgs::default()
+        };
+        let sources = BTreeMap::from([(
+            "claude".to_string(),
+            SourceArgs {
+                shared: shared.clone(),
+                claude_project: Some("project-a".to_string()),
+                ..SourceArgs::default()
+            },
+        )]);
+
+        let daily = load_rows(AgentReportKind::Daily, &shared, &sources, WeekDay::Monday).unwrap();
+
+        assert_eq!(daily.rows.len(), 1);
+        assert_eq!(daily.rows[0].period, "2099-01-02");
+        assert_eq!(daily.rows[0].metadata_agents, Some(vec!["claude", "pi"]));
+        assert_eq!(daily.rows[0].input_tokens, 17);
+        assert_eq!(daily.rows[0].output_tokens, 8);
+        assert!((daily.rows[0].total_cost - 0.01).abs() < f64::EPSILON);
+
+        let sessions =
+            load_rows(AgentReportKind::Session, &shared, &sources, WeekDay::Monday).unwrap();
+
+        assert!(
+            sessions
+                .rows
+                .iter()
+                .any(|row| row.agent == "claude" && row.period == "session-a")
+        );
+        assert!(
+            !sessions
+                .rows
+                .iter()
+                .any(|row| row.agent == "claude" && row.period == "session-b")
+        );
+        assert!(
+            sessions
+                .rows
+                .iter()
+                .any(|row| row.agent == "pi" && row.period == "pi-session")
+        );
+    }
+
     fn isolated_source_environment(fixture: &ccusage_test_support::Fixture) -> EnvVarsGuard {
         isolated_source_environment_with_pi_agent_dir(fixture, "pi/sessions")
     }
 
@@ -15,7 +15,7 @@ use serde_json::{Value, json};
 use super::*;
 use crate::{
     Align, CodexGroup, CodexModelUsage, ModelBreakdown, PricingMap,
-    cli::{AgentReportKind, CodexSpeed, CostMode, SharedArgs, WeekDay},
+    cli::{AgentReportKind, CodexSpeed, CostMode, SharedArgs, SourceArgs, WeekDay},
     loader::NO_SOURCES,
     model_aliases::set_model_aliases_for_tests,
 };
@@ -776,6 +776,70 @@ fn multi_section_claude_fixture_matches_standalone_sections_for_daily_and_sessio
     assert_daily_family_and_session_sections_match_standalone(&shared);
 }
 
+#[test]
+fn multi_section_pi_load_uses_source_options_for_daily_and_session_rows() {
+    let fixture = fs_fixture!({
+        "custom/pi/sessions/project-a/agent_in-range.jsonl": r#"{"type":"message","timestamp":"2099-01-02T00:00:00.000Z","message":{"role":"assistant","model":"gpt-source-config","usage":{"input":1000,"output":500}}}"#,
+        "custom/pi/sessions/project-b/agent_out-of-range.jsonl": r#"{"type":"message","timestamp":"2099-01-03T00:00:00.000Z","message":{"role":"assistant","model":"gpt-source-config","usage":{"input":10000,"output":5000}}}"#,
+    });
+    let _env = isolated_agent_env(
+        &fixture,
+        "PI_AGENT_DIR",
+        fixture.path("empty-default").into_os_string(),
+    );
+    let shared = SharedArgs {
+        mode: CostMode::Calculate,
+        ..fixture_shared("20990101", "20990104")
+    };
+    let sources = std::collections::BTreeMap::from([(
+        "pi".to_string(),
+        SourceArgs {
+            shared: SharedArgs {
+                since: Some("20990102".to_string()),
+                until: Some("20990102".to_string()),
+                pricing_overrides: std::collections::BTreeMap::from([(
+                    "gpt-source-config".to_string(),
+                    crate::cli::PricingOverride {
+                        input_cost_per_token: Some(1e-6),
+                        output_cost_per_token: Some(2e-6),
+                        ..Default::default()
+                    },
+                )]),
+                ..shared.clone()
+            },
+            pi_path: Some(fixture.path("custom/pi").to_string_lossy().into_owned()),
+            ..SourceArgs::default()
+        },
+    )]);
+
+    let sections = load_sections(
+        &[AgentReportKind::Daily, AgentReportKind::Session],
+        &shared,
+        &sources,
+        WeekDay::Monday,
+    )
+    .unwrap();
+    let daily_rows = &sections.sections[0].1;
+    assert_eq!(daily_rows.len(), 1);
+    assert_eq!(daily_rows[0].period, "2099-01-02");
+    assert_eq!(daily_rows[0].metadata_agents, Some(vec!["pi"]));
+    assert_eq!(daily_rows[0].input_tokens, 1_000);
+    assert_eq!(daily_rows[0].output_tokens, 500);
+    assert!((daily_rows[0].total_cost - 0.002).abs() < f64::EPSILON);
+
+    let session_rows = &sections.sections[1].1;
+    assert_eq!(session_rows.len(), 1);
+    assert_eq!(session_rows[0].period, "in-range");
+    assert_eq!(session_rows[0].agent, "pi");
+    assert_eq!(
+        session_rows[0].metadata.as_ref().unwrap()["projectPath"],
+        "project-a"
+    );
+    assert_eq!(session_rows[0].input_tokens, 1_000);
+    assert_eq!(session_rows[0].output_tokens, 500);
+    assert!((session_rows[0].total_cost - 0.002).abs() < f64::EPSILON);
+}
+
 #[test]
 fn multi_section_codex_fixture_matches_standalone_sections_for_daily_and_session_invocations() {
     let _aliases = set_model_aliases_for_tests([("private-alpha", "gpt-5.2")]);
 
@@ -192,6 +192,7 @@ pub struct AgentCommandArgs {
 #[derive(Clone, Debug, Default)]
 pub struct SourceArgs {
     pub shared: SharedArgs,
+    pub claude_project: Option<String>,
     pub pi_path: Option<String>,
     pub open_claw_path: Option<String>,
     pub codex_speed: CodexSpeed,
 
@@ -17,30 +17,38 @@ pub(crate) fn parse() -> Command {
         exit_with_usage(&message);
     });
     let config = ConfigContext::from_args(&arg_strings);
-    let mut command = unified_or_command(parse_with(args.clone(), &config));
-    if let Command::All(unified) = &mut command {
-        sources::resolve(unified, &args, &config);
+    let mut command = unified_or_command(
+        try_parse_with(args.clone(), &config, None)
+            .unwrap_or_else(|message| exit_with_usage(&message)),
+    );
+    if let Command::All(unified) = &mut command
+        && let Err(message) = sources::resolve(unified, &args, &config)
+    {
+        exit_with_usage(&message);
     }
     command
 }
 
 /// Parses one command line against one view of the config, with the checks
 /// and resolutions that need the parsed command.
-fn parse_with(args: Vec<OsString>, config: &ConfigContext) -> Cli {
+fn try_parse_with(
+    args: Vec<OsString>,
+    config: &ConfigContext,
+    unified_week_start: Option<WeekDay>,
+) -> Result<Cli, String> {
     let mut cli = Cli::parse_from_with_config(
         args,
         config,
         DEFAULT_SESSION_DURATION_HOURS,
         env!("CCUSAGE_VERSION"),
-    )
-    .unwrap_or_else(|message| exit_with_usage(&message));
-    if let Err(message) = timezone::validate(&cli) {
-        exit_with_usage(&message);
-    }
-    if let Err(message) = last_window::resolve(&mut cli) {
-        exit_with_usage(&message);
+    )?;
+    if let (Some(start_of_week), Some(Command::All(args))) = (unified_week_start, &mut cli.command)
+    {
+        args.start_of_week = start_of_week;
     }
-    cli
+    timezone::validate(&cli)?;
+    last_window::resolve(&mut cli)?;
+    Ok(cli)
 }
 
 /// A bare `ccusage` is the unified daily report over the root options.