beancount-cli 0.2.13__tar.gz → 0.2.14__tar.gz

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/.gitignore

@@ -25,3 +25,4 @@ build/
 .vscode/
 *.swp
 .DS_Store
+/Ledger/

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/CHANGELOG.md

@@ -5,6 +5,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.2.14] - 2026-06-02
+
+### Added
+- `account pad-balance`: insert a `pad` + `balance` directive pair directly into the ledger.
+
+### Changed
+- `--stdin` flag renamed to `--input` across all commands that read from standard input.
+
 ## [0.2.13] - 2026-04-17
 
 ### Added

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: beancount-cli
-Version: 0.2.13
+Version: 0.2.14
 Summary: A CLI tool to manage Beancount ledgers
 Project-URL: Homepage, https://github.com/romamo/beancount-cli
 Project-URL: Repository, https://github.com/romamo/beancount-cli
@@ -20,12 +20,12 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Office/Business :: Financial :: Accounting
 Requires-Python: >=3.10
-Requires-Dist: agentyper==0.1.12
-Requires-Dist: beancount>=3.0.0
+Requires-Dist: agentyper==0.1.13
+Requires-Dist: beancount==3.2.3
 Requires-Dist: beanprice2>=2.1.0
 Requires-Dist: beanquery>=0.1.0
-Requires-Dist: pydantic-settings>=2.0.0
-Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pydantic-settings==2.14.1
+Requires-Dist: pydantic==2.13.4
 Requires-Dist: python-dateutil>=2.8.2
 Description-Content-Type: text/markdown
 

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "beancount-cli"
-version = "0.2.13"
+version = "0.2.14"
 description = "A CLI tool to manage Beancount ledgers"
 readme = "README.md"
 authors = [
@@ -9,13 +9,13 @@ authors = [
 license = { text = "MIT" }
 requires-python = ">=3.10"
 dependencies = [
-    "beancount>=3.0.0",
+    "beancount==3.2.3",
     "beanquery>=0.1.0",
-    "pydantic>=2.0.0",
+    "pydantic==2.13.4",
     "python-dateutil>=2.8.2",
     "beanprice2>=2.1.0",
-    "pydantic-settings>=2.0.0",
-    "agentyper==0.1.12",
+    "pydantic-settings==2.14.1",
+    "agentyper==0.1.13",
 ]
 keywords = ["beancount", "cli", "accounting", "automation", "agent"]
 classifiers = [

beancount_cli-0.2.14/src/beancount_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.14"

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/src/beancount_cli/adapters.py

@@ -8,6 +8,7 @@ from beancount_cli.models import (
     BalanceModel,
     CostModel,
     CurrencyCode,
+    PadBalanceModel,
     PostingModel,
     TransactionModel,
 )
@@ -110,3 +111,30 @@ def to_core_balance(model: BalanceModel) -> data.Balance:
         diff_amount=None,
         tolerance=None,
     )
+
+
+def to_core_pad(model: PadBalanceModel) -> tuple[data.Pad, data.Balance]:
+    """Convert a PadBalanceModel into a (Pad, Balance) directive pair.
+
+    The Pad directive is dated one day before the Balance assertion by default,
+    which is the standard Beancount pattern to avoid the 'Unused Pad entry' error.
+    """
+    import datetime
+
+    pad_date = model.pad_date or (model.balance_date - datetime.timedelta(days=1))
+
+    pad = data.Pad(
+        meta=model.meta or {},
+        date=pad_date,
+        account=str(model.account),
+        source_account=str(model.pad_account),
+    )
+    balance = data.Balance(
+        meta={},
+        date=model.balance_date,
+        account=str(model.account),
+        amount=to_core_amount(model.amount),
+        diff_amount=None,
+        tolerance=None,
+    )
+    return pad, balance

beancount_cli-0.2.14/src/beancount_cli/commands/account.py

@@ -0,0 +1,202 @@
+import json
+import sys
+from datetime import date
+from pathlib import Path
+
+import agentyper as typer
+from pydantic import TypeAdapter
+
+from beancount_cli.commands.common import (
+    _is_table_format,
+    console,
+    get_ledger_file,
+    read_json_input,
+)
+from beancount_cli.models import AccountModel, BalanceModel, PadBalanceModel
+from beancount_cli.services import AccountService
+
+app = typer.Agentyper(help="Manage accounts.")
+
+
+@app.command(name="list")
+def account_list(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+):
+    """List all accounts."""
+    actual_file = get_ledger_file(file)
+    service = AccountService(actual_file)
+    accounts = service.list_accounts()
+
+    if _is_table_format():
+        data = [
+            {
+                "Account": acc.name,
+                "Open Date": str(acc.open_date),
+                "Currencies": ", ".join(acc.currencies),
+            }
+            for acc in accounts
+        ]
+        typer.output(data, title=f"Accounts ({len(accounts)})")
+    else:
+        typer.output(accounts, title=f"Accounts ({len(accounts)})")
+
+
+@app.command(name="create")
+def account_create(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    name: str | None = typer.Option(None, "--name", "-n", help="Account name (e.g. Assets:Bank)"),
+    currency_opt: str | None = typer.Option(
+        None, "--currency", "-c", help="Currencies (comma-separated)"
+    ),
+    open_date: str | None = typer.Option(None, "--date", "-d", help="Open date (YYYY-MM-DD)"),
+    json_data: str | None = typer.Option(
+        None, "--input", "-i", help="JSON string data (or '-' to read from STDIN)"
+    ),
+    target: Path | None = typer.Option(None, "--target", help="Override target file to write to"),
+):
+    """Create a new account."""
+    actual_file = get_ledger_file(file)
+    service = AccountService(actual_file)
+
+    if json_data:
+        data_input = json.loads(read_json_input(json_data))
+        if isinstance(data_input, list):
+            ta = TypeAdapter(list[AccountModel])
+            models = ta.validate_python(data_input)
+            for m in models:
+                service.create_account(m, target_file=target)
+                console.print(f"[green]Account {m.name} created.[/green]")
+        else:
+            model = AccountModel(**data_input)
+            service.create_account(model, target_file=target)
+            console.print(f"[green]Account {model.name} created.[/green]")
+    else:
+        if not name:
+            console.print("[red]Error: --name is required if not using --input.[/red]")
+            sys.exit(typer.EXIT_VALIDATION)
+
+        d = date.today()
+        if open_date:
+            d = date.fromisoformat(open_date)
+
+        currencies = [c.strip() for c in currency_opt.split(",")] if currency_opt else []
+        model = AccountModel(name=name, open_date=d, currencies=currencies)
+        service.create_account(model, target_file=target)
+        console.print(f"[green]Account {name} created.[/green]")
+
+
+@app.command(name="balance")
+def account_balance(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    json_data: str = typer.Option(
+        ..., "--input", "-i", help="JSON string data (or '-' to read from STDIN)"
+    ),
+    target: Path | None = typer.Option(None, "--target", help="Override target file to write to"),
+):
+    """Add a balance directive for an account."""
+    actual_file = get_ledger_file(file)
+    service = AccountService(actual_file)
+
+    data_input = json.loads(read_json_input(json_data))
+    model = BalanceModel(**data_input)
+    service.add_balance(model, target_file=target)
+    console.print(f"[green]Balance check for {model.account} added.[/green]")
+
+
+@app.command(name="pad-balance")
+def account_pad_balance(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    account: str | None = typer.Option(
+        None, "--account", help="Account to adjust (e.g. Assets:BE:Wise:EUR)"
+    ),
+    amount: str | None = typer.Option(
+        None, "--amount", help="Target balance amount (e.g. 1777.00)"
+    ),
+    currency: str | None = typer.Option(
+        None, "--currency", "-c", help="Currency of the target balance (e.g. EUR)"
+    ),
+    pad_account: str | None = typer.Option(
+        None,
+        "--pad-account",
+        "-p",
+        help="Account to absorb the difference (e.g. Expenses:Other)",
+    ),
+    balance_date: str | None = typer.Option(
+        None,
+        "--date",
+        "-d",
+        help="Date of the balance assertion (YYYY-MM-DD). Defaults to today.",
+    ),
+    pad_date: str | None = typer.Option(
+        None,
+        "--pad-date",
+        help="Date of the pad directive (YYYY-MM-DD). Defaults to balance-date minus 1 day.",
+    ),
+    json_data: str | None = typer.Option(
+        None, "--input", "-i", help="JSON string data (or '-' to read from STDIN)"
+    ),
+    target: Path | None = typer.Option(None, "--target", help="Override target file to write to"),
+):
+    """Adjust an account balance using a Pad + Balance directive pair.
+
+    Beancount inserts a synthetic transaction to bring ACCOUNT to AMOUNT
+    on BALANCE-DATE.  The adjustment is automatically booked to PAD-ACCOUNT.
+
+    Example:
+      uv run bean account pad-balance \\
+        --account Assets:BE:Wise:EUR \\
+        --amount 1777 --currency EUR \\
+        --pad-account Expenses:Other
+
+    JSON example (for agent pipelines):
+      echo '{"account": "Assets:BE:Wise:EUR", "amount": {"number": 1777, "currency": "EUR"}, \\
+             "pad_account": "Expenses:Other", "balance_date": "2026-06-02"}' \\
+        | uv run bean account pad-balance --input -
+    """
+    actual_file = get_ledger_file(file)
+    service = AccountService(actual_file)
+
+    if json_data:
+        data_input = json.loads(read_json_input(json_data))
+        model = PadBalanceModel(**data_input)
+    else:
+        missing = [
+            f
+            for f, v in [
+                ("--account", account),
+                ("--amount", amount),
+                ("--currency", currency),
+                ("--pad-account", pad_account),
+            ]
+            if not v
+        ]
+        if missing:
+            console.print(
+                f"[red]Error: {', '.join(missing)} required when not using --input.[/red]"
+            )
+            sys.exit(typer.EXIT_VALIDATION)
+
+        b_date = date.fromisoformat(balance_date) if balance_date else date.today()
+        p_date = date.fromisoformat(pad_date) if pad_date else None
+
+        model = PadBalanceModel(
+            balance_date=b_date,
+            account=account,  # type: ignore[arg-type]
+            amount={"number": amount, "currency": currency},
+            pad_account=pad_account,  # type: ignore[arg-type]
+            pad_date=p_date,
+        )
+
+    service.add_pad_balance(model, target_file=target)
+    console.print(
+        f"[green]Pad + Balance for {model.account} → {model.amount.number} "
+        f"{model.amount.currency} added.[/green]"
+    )

beancount_cli-0.2.14/src/beancount_cli/commands/commodity.py

@@ -0,0 +1,193 @@
+import json
+import logging
+import sys
+from pathlib import Path
+
+import agentyper as typer
+from beancount.core import data
+from beancount.parser import parser as bp_parser
+
+from beancount_cli.commands.common import (
+    _is_table_format,
+    console,
+    error_console,
+    get_ledger_file,
+    read_json_input,
+    read_stdin,
+)
+from beancount_cli.models import CommodityModel
+from beancount_cli.services import CommodityService
+
+app = typer.Agentyper(help="Manage commodities.")
+
+
+@app.command(name="list")
+def commodity_list(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    asset_class: str | None = typer.Option(
+        None, "--asset-class", "-c", help="Filter by asset-class meta (e.g. stock, Cash)"
+    ),
+):
+    """List all commodities."""
+    actual_file = get_ledger_file(file)
+    service = CommodityService(actual_file)
+    commodities = service.list_commodities(asset_class=asset_class)
+
+    if _is_table_format():
+        data = [
+            {
+                "Currency": c.currency,
+                "Date": str(c.date) if c.date else "",
+                "Name": c.meta.get("name", "") if c.meta else "",
+            }
+            for c in commodities
+        ]
+        typer.output(data, title=f"Commodities ({len(commodities)})")
+    else:
+        typer.output(commodities, title=f"Commodities ({len(commodities)})")
+
+
+@app.command(name="check")
+def commodity_check(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+):
+    """Check for currencies used in transactions but missing a commodity directive."""
+    actual_file = get_ledger_file(file)
+    service = CommodityService(actual_file)
+    undeclared = service.get_undeclared_commodities()
+
+    if _is_table_format():
+        if not undeclared:
+            console.print("[green]All used currencies are declared.[/green]")
+        else:
+            typer.output(undeclared, title=f"Undeclared Commodities ({len(undeclared)})")
+    else:
+        typer.output(undeclared, title="Undeclared Commodities")
+
+
+@app.command(name="export")
+def commodity_export(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    asset_class: str | None = typer.Option(
+        None, "--asset-class", "-c", help="Filter by asset-class meta (e.g. stock, Cash)"
+    ),
+    output_file: Path | None = typer.Option(
+        None, "--output-file", help="Write output to file (default: commodities_file or stdout)"
+    ),
+):
+    """Export commodities as beancount directives."""
+    actual_file = get_ledger_file(file)
+    service = CommodityService(actual_file)
+    commodities = service.list_commodities(asset_class=asset_class)
+
+    content = "\n".join(service._format_commodity_block(c) for c in commodities)
+
+    dest = output_file or service.ledger_service.get_commodities_file()
+    if dest:
+        dest.write_text(content)
+        console.print(f"[green]Exported {len(commodities)} commodities →[/green] {dest}")
+    else:
+        sys.stdout.write(content)
+
+
+@app.command(name="import", mutating=True)
+def commodity_import(
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    input_file: Path | None = typer.Option(
+        None, "--input-file", help="Read beancount directives from file instead of stdin"
+    ),
+    output_file: Path | None = typer.Option(
+        None, "--output-file", help="Write to file (default: commodities_file from ledger config)"
+    ),
+    overwrite: bool = typer.Option(False, "--overwrite", help="Overwrite existing commodities"),
+    dry_run: bool = False,
+):
+    """Import commodity directives from stdin (or --input-file) into the commodities_file."""
+    stdin_text = Path(input_file).read_text() if input_file else read_stdin()
+    entries, errors, _ = bp_parser.parse_string(stdin_text)
+    if errors:
+        for e in errors:
+            console.print(f"[red]Parse error: {e.message}[/red]")
+        sys.exit(typer.EXIT_VALIDATION)
+
+    commodities = [
+        CommodityModel(currency=e.currency, date=e.date, meta=e.meta)
+        for e in entries
+        if isinstance(e, data.Commodity)
+    ]
+    if not commodities:
+        console.print("[yellow]No commodity directives found in stdin.[/yellow]")
+        return
+
+    actual_file = get_ledger_file(file)
+    service = CommodityService(actual_file)
+    dest = output_file or service.ledger_service.get_commodities_file()
+
+    results, commodities_file = service.import_commodities(
+        commodities, output_file=dest, overwrite=overwrite, dry_run=dry_run
+    )
+
+    stdout_mode = not dry_run and commodities_file is None
+    status_console = error_console if stdout_mode else console
+    verbose = logging.getLogger().isEnabledFor(logging.INFO)
+    prefix = "[dim](dry-run)[/dim] " if dry_run else ""
+    for r in results:
+        if not verbose and not dry_run and r.action == "skipped":
+            continue
+        color = {"added": "green", "overwritten": "yellow", "skipped": "dim"}.get(r.action, "white")
+        status_console.print(f"{prefix}[{color}]{r.action:12}[/{color}] {r.currency}")
+
+    if dry_run:
+        return
+
+    if commodities_file:
+        console.print(f"\n[green]Done →[/green] {commodities_file}")
+    else:
+        # No destination configured — stream added/overwritten entries to stdout
+        written = {r.currency for r in results if r.action != "skipped"}
+        for c in commodities:
+            if str(c.currency) in written:
+                sys.stdout.write(service._format_commodity_block(c))
+
+
+@app.command(name="create")
+def commodity_create(
+    currency: str | None = typer.Argument(None, help="Currency code (e.g. USD)"),
+    file: Path | None = typer.Option(
+        None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
+    ),
+    name: str | None = typer.Option(None, "--name", "-n", help="Full name"),
+    json_data: str | None = typer.Option(
+        None, "--input", "-i", help="JSON string data (or '-' to read from STDIN)"
+    ),
+):
+    """Create a new commodity."""
+    actual_file = get_ledger_file(file)
+    service = CommodityService(actual_file)
+
+    if json_data:
+        data_input = json.loads(read_json_input(json_data))
+        items = data_input if isinstance(data_input, list) else [data_input]
+        for item in items:
+            curr = item.get("currency")
+            comm_name = item.get("name")
+            if not curr:
+                console.print(f"[yellow]Skipping invalid commodity entry: {item}[/yellow]")
+                continue
+            meta = {k: v for k, v in item.items() if k not in ("currency", "name")}
+            service.create_commodity(curr, name=comm_name, meta=meta)
+            console.print(f"[green]Commodity {curr} created.[/green]")
+    else:
+        if not currency:
+            console.print("[red]Error: currency argument is required if not using --input.[/red]")
+            sys.exit(typer.EXIT_VALIDATION)
+        service.create_commodity(currency, name=name)
+        console.print(f"[green]Commodity {currency} created.[/green]")

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/src/beancount_cli/commands/common.py

@@ -15,6 +15,30 @@ console = Console(width=_width)
 error_console = Console(stderr=True, width=_width)
 
 
+_STDIN_MAX_BYTES = 65_536
+
+
+def read_stdin() -> str:
+    """Read text from stdin, guarding against TTY deadlock and pipe-buffer overflow (§50, §61)."""
+    import agentyper as typer
+
+    if sys.stdin.isatty():
+        error_console.print(
+            "[red]Error: stdin is a TTY — pipe input or use --input-file PATH.[/red]"
+        )
+        sys.exit(typer.EXIT_VALIDATION)
+
+    chunk = sys.stdin.buffer.read(_STDIN_MAX_BYTES + 1)
+    if len(chunk) > _STDIN_MAX_BYTES:
+        error_console.print(
+            f"[red]Error: stdin exceeds {_STDIN_MAX_BYTES // 1024} KB limit."
+            " Use --input-file PATH for large payloads.[/red]"
+        )
+        sys.exit(typer.EXIT_VALIDATION)
+
+    return chunk.decode()
+
+
 def read_json_input(json_data: str) -> str:
     """Read JSON from a string or from STDIN when json_data is '-'."""
     if json_data == "-":

{beancount_cli-0.2.13 → beancount_cli-0.2.14}/src/beancount_cli/commands/price.py

@@ -9,6 +9,7 @@ from tempfile import gettempdir
 import agentyper as typer
 from beancount.core import data
 from beancount.core.data import sorted as bean_sorted
+from beancount.ops import lifetimes as bean_lifetimes
 from beancount.parser import printer
 from beanprice import price as bp_price
 
@@ -20,7 +21,6 @@ app = typer.Agentyper(help="Manage prices.")
 
 @app.command(name="check")
 def price_check(
-    ledger_file: Path | None = typer.Argument(None, help="Path to ledger file"),
     file: Path | None = typer.Option(
         None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
     ),
@@ -32,7 +32,7 @@ def price_check(
     ),
 ):
     """Check for missing price data in the ledger."""
-    actual_file = get_ledger_file(ledger_file or file)
+    actual_file = get_ledger_file(file)
     ledger_service = LedgerService(actual_file)
     price_service = PriceService(ledger_service)
 
@@ -61,7 +61,6 @@ def price_check(
 
 @app.command(name="check-anomalies")
 def price_check_anomalies(
-    ledger_file: Path | None = typer.Argument(None, help="Path to ledger file"),
     file: Path | None = typer.Option(
         None, "--file", "-f", envvar="BEANCOUNT_FILE", help="Main beancount file"
     ),
@@ -73,7 +72,7 @@ def price_check_anomalies(
     ),
 ):
     """Check for sudden price jumps or drops in the ledger."""
-    actual_file = get_ledger_file(ledger_file or file)
+    actual_file = get_ledger_file(file)
     ledger_service = LedgerService(actual_file)
     price_service = PriceService(ledger_service)
 
@@ -162,14 +161,19 @@ def price_fetch(
 
         assert primary_ledger_service is not None  # always set — files_to_load is non-empty
 
-        _warn_missing_price_meta_entries(entries, "Skipping fetch.")
+        _warn_missing_price_meta_entries(
+            entries, "Skipping fetch.", primary_ledger_service.get_operating_currencies()
+        )
 
-        if update or fill_gaps:
-            jobs = bp_price.get_price_jobs_up_to_date(
-                entries, date_last=datetime.now().date(), inactive=inactive
-            )
-        else:
-            jobs = bp_price.get_price_jobs_at_date(entries, date=None, inactive=inactive)
+        date_last = datetime.now().date()
+        jobs = _resolve_price_jobs(entries, date_last, inactive, update, fill_gaps)
+
+        if not inactive:
+            inactive_jobs = _resolve_price_jobs(entries, date_last, True, update, fill_gaps)
+            cash_jobs = _get_cash_currency_jobs(entries, date_last, inactive_jobs)
+            if cash_jobs:
+                existing = {(j.base, j.quote, j.date) for j in jobs}
+                jobs.extend(j for j in cash_jobs if (j.base, j.quote, j.date) not in existing)
 
         if not jobs:
             error_console.print("[yellow]No price jobs to execute.[/yellow]")
@@ -283,6 +287,44 @@ def price_fetch(
         sys.exit(typer.EXIT_SYSTEM)
 
 
+def _resolve_price_jobs(
+    entries: list[data.Directive],
+    date_last: date,
+    inactive: bool,
+    update: bool,
+    fill_gaps: bool,
+) -> list:
+    if update or fill_gaps:
+        return bp_price.get_price_jobs_up_to_date(entries, date_last=date_last, inactive=inactive)
+    return bp_price.get_price_jobs_at_date(entries, date=None, inactive=inactive)
+
+
+def _get_cash_currency_jobs(
+    entries: list[data.Directive],
+    date_last: date,
+    inactive_jobs: list,
+) -> list:
+    """Return price jobs for currencies held as cash that beanprice silently drops.
+
+    beanprice's lifetimes tracker keys holdings as (currency, cost_currency). Cash
+    currencies produce (base, None) keys, but declared price sources register as
+    (base, quote) — they never match, so the filter at price.py:478 drops them.
+    """
+    raw_lifetimes = bean_lifetimes.get_commodity_lifetimes(entries)
+    cash_bases = {
+        base for (base, cost), intervals in raw_lifetimes.items() if cost is None and intervals
+    }
+    if not cash_bases:
+        return []
+
+    declared_triples = bp_price.find_currencies_declared(entries, date_last)
+    cash_pairs = {(base, quote) for base, quote, _ in declared_triples if base in cash_bases}
+    if not cash_pairs:
+        return []
+
+    return [job for job in inactive_jobs if (job.base, job.quote) in cash_pairs]
+
+
 def _find_price_file(tree: dict) -> Path | None:
     """Search an include tree for a beancount file with 'price' in its name or parent directory."""
     for k, v in tree.items():
@@ -298,10 +340,14 @@ def _find_price_file(tree: dict) -> Path | None:
 
 def _warn_missing_price_meta(ledger_service: LedgerService, context: str) -> None:
     """Warn about held commodities that lack 'price' metadata and cannot be priced."""
-    _warn_missing_price_meta_entries(ledger_service.entries, context)
+    _warn_missing_price_meta_entries(
+        ledger_service.entries, context, ledger_service.get_operating_currencies()
+    )
 
 
-def _warn_missing_price_meta_entries(entries: list[data.Directive], context: str) -> None:
+def _warn_missing_price_meta_entries(
+    entries: list[data.Directive], context: str, operating_currencies: list[str] | None = None
+) -> None:
     """Warn about held commodities (from a merged entry list) that lack 'price' metadata."""
     from beancount.core import convert
     from beancount.core.inventory import Inventory
@@ -322,13 +368,11 @@ def _warn_missing_price_meta_entries(entries: list[data.Directive], context: str
         if not pos.units.number.is_zero()
     }
 
-    # Extract operating currencies from options if possible
-    # In a merged entry list, we might have 'option' directives as Custom entries or similar?
-    # Actually, Beancount usually loads them into an options map.
-    # For now, we'll just check commodity metadata.
-
+    excluded = set(operating_currencies or [])
     commodity_meta = {e.currency: e.meta for e in entries if isinstance(e, data.Commodity)}
     for curr in sorted(held):
+        if curr in excluded:
+            continue
         meta = commodity_meta.get(curr, {})
         if not meta or "price" not in meta:
             error_console.print(