sac-capital 0.1.0__tar.gz

sac_capital-0.1.0/.gitignore

@@ -0,0 +1,53 @@
+# Virtual environment
+.venv/
+
+# Python bytecode
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# Environment
+.env
+
+# Data files
+*.csv
+*.jsonl
+*.log
+/data/
+*.db
+
+# Exploratory spikes
+spike/
+
+# Distribution / packaging
+dist/
+build/
+*.egg-info/
+.eggs/
+frontend/dist/
+frontend/node_modules/
+frontend/*.tsbuildinfo
+broadcast/
+cache/
+contracts/out/
+
+# Testing / coverage
+.pytest_cache/
+.coverage
+htmlcov/
+
+# Type checking
+.mypy_cache/
+.ruff_cache/
+
+# IDEs
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+.vercel

sac_capital-0.1.0/.python-version

@@ -0,0 +1 @@
+3.12

sac_capital-0.1.0/.superpowers/sdd/.gitignore

@@ -0,0 +1 @@
+*

sac_capital-0.1.0/.superpowers/sdd/progress.md

@@ -0,0 +1,34 @@
+# Progress — Plan 2026-07-03 hardening-and-alpha-improvements
+
+Branch: hardening-2026-07
+Base: 0e16157680c3c3aa5b4a3ed1946d57739a0f2726
+
+Task 0 (secrets rotation): USER ACTION REQUIRED (Mantle key + Telegram token) — deferred
+Task 1: complete (commits 0e16157..0e2922d, review clean)
+Task 2: complete (commits 0e2922d..b45c9c0, review clean)
+Task 3: complete (commits b45c9c0..efb6182, review clean)
+  Minor (deferred to final review): _has_active_broker_order now unused in runner_equities.py
+Task 4: complete (commits efb6182..15630ac, review clean)
+Task 5: complete (commits 15630ac..551ed24, review clean)
+Task 6: complete (commits 551ed24..217aef0, review clean) — PHASE 1 DONE
+Task 10: complete (commits 20e38d5..4d25d58, review clean)
+Task 11: complete (commits 4d25d58..ab17e0b, review clean)
+
+# Progress — Plan 2026-07-04 sac-capital-cli
+
+Branch: feat/sac-cli
+Base: 1adb9d9
+Baseline: 4 pre-existing failures in equities/data/tests/test_senate_efd_disclosures.py (not ours)
+
+Task 1: complete (commits 1adb9d9..b288e44, review clean after 1 fix)
+Task 2: complete (commits b288e44..dbd5bdd, review clean)
+  Minor (deferred to final review): repo mode does not ensure data/ subdir exists
+Task 3: complete (commits dbd5bdd..334acae, review clean after 1 fix)
+Task 4: complete (commits 334acae..ff12ec7, review clean after 2 security fixes: env injection, 0600 perms)
+  Minor (deferred to final review): getpass echo for secrets; empty ALPACA_SECRET_KEY when key id given
+Task 5: complete (commits ff12ec7..5d0e5c2, review clean; REMAINDER deviation verified necessary)
+  Minor (deferred to final review): dead return-2 lines cli/main.py:67,98; dict(_COMMANDS) rebuilt per call
+Task 6: complete (commits 5d0e5c2..7a94bb2, review clean)
+  Minor (deferred to final review): broadcast in wheel packages list is inert config
+Task 7: complete (commits 7a94bb2..64fb6b2, review clean)
+Task 8: complete (full suite 786 pass/4 baseline, build+install smoke OK, final review READY TO MERGE, all 6 minors triaged fine-to-defer)

sac_capital-0.1.0/.superpowers/sdd/review-00b6b02..334acae.diff

@@ -0,0 +1,77 @@
+# Review package: 00b6b02..HEAD
+
+## Commits
+334acae test(llm): lock claude_cli subprocess contract; fix stale docstring
+
+## Files changed
+ core/claude_client.py      |  2 +-
+ tests/test_llm_provider.py | 24 ++++++++++++++++++++++++
+ 2 files changed, 25 insertions(+), 1 deletion(-)
+
+## Diff
+diff --git a/core/claude_client.py b/core/claude_client.py
+index 82da04b..bd2a545 100644
+--- a/core/claude_client.py
++++ b/core/claude_client.py
+@@ -246,21 +246,21 @@ class CodexCLIClient:
+             output_tokens=len(text) // 4,
+         )
+ 
+ 
+ class ClaudeCodeClient:
+     """Backward-compatible client.
+ 
+     Provider selection:
+       - LLM_PROVIDER=codex     -> local Codex CLI / ChatGPT login
+       - LLM_PROVIDER=openai    -> OpenAI API (requires OPENAI_API_KEY)
+-      - LLM_PROVIDER=claude    -> Claude CLI
++      - LLM_PROVIDER=claude_cli -> Claude CLI
+       - LLM_PROVIDER=anthropic -> Anthropic SDK
+       - blank / auto           -> Codex CLI
+ 
+     Args:
+         timeout: Max seconds to wait for a response (default 60).
+     """
+ 
+     _MODEL_MAP = {
+         "claude-haiku-4-5-20251001": "claude-haiku-4-5-20251001",
+         "claude-sonnet-4-6":         "claude-sonnet-4-6",
+diff --git a/tests/test_llm_provider.py b/tests/test_llm_provider.py
+index aa9519e..b556961 100644
+--- a/tests/test_llm_provider.py
++++ b/tests/test_llm_provider.py
+@@ -215,10 +215,34 @@ def test_claude_cli_provider_is_first_class(monkeypatch):
+     calls = {}
+ 
+     def fake_cli(system, user, model):
+         calls["model"] = model
+         return LLMResponse(content="ok", input_tokens=1, output_tokens=1)
+ 
+     client._complete_with_claude_cli = fake_cli
+     resp = client.complete("sys", "usr", "fast")
+     assert resp.content == "ok"
+     assert calls["model"] == "fast"
++
++
++def test_claude_cli_provider_invokes_claude_binary_via_subprocess(monkeypatch):
++    """LLM_PROVIDER=claude_cli must shell out to `claude -p --model <mapped>` via
++    subprocess, pass the prompt via `input`, and raise on nonzero returncode."""
++    monkeypatch.delenv("ANTHROPIC_API_KEY", raising=False)
++    monkeypatch.delenv("OPENAI_API_KEY", raising=False)
++    monkeypatch.setenv("LLM_PROVIDER", "claude_cli")
++
++    calls = {}
++
++    def fake_run(args, input, capture_output, text, timeout, start_new_session=False):
++        calls["args"] = args
++        calls["input"] = input
++        return SimpleNamespace(returncode=1, stderr="boom", stdout="")
++
++    monkeypatch.setattr("core.claude_client.subprocess.run", fake_run)
++    client = ClaudeCodeClient()
++
++    with pytest.raises(RuntimeError, match="boom"):
++        client.complete("sys", "usr", "strong")
++
++    assert calls["args"][:4] == ["claude", "-p", "--model", "claude-sonnet-4-6"]
++    assert "sys" in calls["input"] and "usr" in calls["input"]

sac_capital-0.1.0/.superpowers/sdd/review-0e16157..0e2922d.diff

@@ -0,0 +1,269 @@
+# Review package: 0e16157..HEAD
+
+## Commits
+0e2922d fix(risk): only persist kernel state when it changes
+f9e5d04 fix(risk): persist high-water mark and halt flag across runner restarts
+
+## Files changed
+ .superpowers/sdd/progress.md        | 12 +++-----
+ equities/risk/kernel.py             | 19 +++++++++++++
+ equities/risk/state.py              | 35 +++++++++++++++++++++++
+ runner_equities.py                  |  1 +
+ tests/equities/test_kernel_state.py | 55 +++++++++++++++++++++++++++++++++++++
+ 5 files changed, 114 insertions(+), 8 deletions(-)
+
+## Diff
+diff --git a/.superpowers/sdd/progress.md b/.superpowers/sdd/progress.md
+index 10f7e59..339d3bb 100644
+--- a/.superpowers/sdd/progress.md
++++ b/.superpowers/sdd/progress.md
+@@ -1,10 +1,6 @@
+-# Progress — Plan 08 situational-awareness-additions
++# Progress — Plan 2026-07-03 hardening-and-alpha-improvements
+ 
+-Branch: situational-awareness-additions
+-Base: d5cb4d513d7207f4ebd3415714a112168b60aaf5
++Branch: hardening-2026-07
++Base: 0e16157680c3c3aa5b4a3ed1946d57739a0f2726
+ 
+-Task 1 (Gap 4 preflight): complete (commits d5cb4d5..162e105, review clean)
+-Task 2 (Gap 1 calibration): complete (commits 162e105..7b3b434, review clean)
+-Task 3 (Gap 2 citation linkage): complete (commits 7b3b434..84d3fdc, review clean)
+-Task 4 (Gap 3 run manifest): complete (commits 84d3fdc..2c1fa4d, review clean)
+-Task 5 (Gap 5 nightly digest): complete (commits 2c1fa4d..21cfe78, review clean)
++Task 0 (secrets rotation): USER ACTION REQUIRED (Mantle key + Telegram token) — deferred
+diff --git a/equities/risk/kernel.py b/equities/risk/kernel.py
+index daef72d..5810cde 100644
+--- a/equities/risk/kernel.py
++++ b/equities/risk/kernel.py
+@@ -11,20 +11,21 @@ Fuses enforced:
+ - Per-name concentration: no single name > max_name_pct of swing sleeve
+ - Max daily loss: halts new entries for the day when breached
+ - Max total drawdown circuit-breaker: halts ALL trading
+ - Real-money promotion gate: LIVE flag absent by default
+ """
+ from __future__ import annotations
+ 
+ import math
+ from dataclasses import dataclass
+ from datetime import date
++from pathlib import Path
+ from typing import Any
+ 
+ from equities.risk.sizing import size_shares, _DEFAULT_GAP_PCT
+ 
+ 
+ @dataclass(frozen=True)
+ class SizedRecommendation:
+     """A Recommendation approved and sized by the risk kernel."""
+ 
+     # Forward-ref import avoided — using Any for the Recommendation type
+@@ -52,37 +53,48 @@ class RiskKernel:
+     def __init__(
+         self,
+         capital: float,
+         risk_pct: float = 0.02,
+         max_positions: int = 4,
+         max_name_pct: float = 0.25,
+         max_sector_pct: float = 0.35,
+         daily_loss_limit_pct: float = 0.05,
+         drawdown_limit_pct: float = 0.15,
+         gap_pct: float = _DEFAULT_GAP_PCT,
++        state_path: Path | None = None,
+     ) -> None:
+         if capital <= 0:
+             raise ValueError(f"RiskKernel capital must be positive, got {capital}")
+         self.capital = capital
+         self.risk_pct = risk_pct
+         self.max_positions = max_positions
+         self.max_name_pct = max_name_pct
+         self.max_sector_pct = max_sector_pct
+         self.daily_loss_limit_pct = daily_loss_limit_pct
+         self.drawdown_limit_pct = drawdown_limit_pct
+         self.gap_pct = gap_pct
+ 
++        self._state_path = state_path
+         self._high_water_mark = capital
+         self._today = date.today().isoformat()
+         self._daily_loss = 0.0
+         self._halted = False  # circuit-breaker flag
+ 
++        # Load persisted state if available
++        if state_path is not None:
++            from equities.risk.state import load_kernel_state
++            saved = load_kernel_state(state_path)
++            if float(saved.get("capital", capital)) == capital:
++                self._high_water_mark = max(capital, float(saved.get("high_water_mark", capital)))
++                self._halted = bool(saved.get("halted", False))
++            # else: bankroll changed in config -> stale hwm/halt discarded, fresh baseline
++
+     # ------------------------------------------------------------------
+     # Public API
+     # ------------------------------------------------------------------
+ 
+     def approve(
+         self,
+         recommendation: Any,
+         open_positions: list[dict[str, Any]],
+         today_realized_loss: float = 0.0,
+         current_equity: float | None = None,
+@@ -95,24 +107,31 @@ class RiskKernel:
+             open_positions:       Current open positions (list of dicts from EquityLedger).
+             today_realized_loss:  Sum of today's closed pnl (negative = loss, positive = gain).
+             current_equity:       Current total equity for drawdown check (None = skip).
+         """
+         # --- Circuit-breaker ---
+         if self._halted:
+             return SizedRecommendation(recommendation, 0.0, False, "circuit_breaker_tripped")
+ 
+         # --- Drawdown check ---
+         if current_equity is not None:
++            prior_hwm = self._high_water_mark
++            prior_halted = self._halted
+             self._high_water_mark = max(self._high_water_mark, current_equity)
+             drawdown = (self._high_water_mark - current_equity) / self._high_water_mark
+             if drawdown >= self.drawdown_limit_pct:
+                 self._halted = True
++            # Save state only if it changed
++            if self._state_path is not None and (self._high_water_mark != prior_hwm or self._halted != prior_halted):
++                from equities.risk.state import save_kernel_state
++                save_kernel_state(self._state_path, self._high_water_mark, self._halted, self.capital)
++            if drawdown >= self.drawdown_limit_pct:
+                 return SizedRecommendation(recommendation, 0.0, False, f"drawdown={drawdown:.1%}_exceeds_{self.drawdown_limit_pct:.0%}")
+ 
+         # --- Daily loss halt ---
+         if today_realized_loss < -(self.daily_loss_limit_pct * self.capital):
+             return SizedRecommendation(recommendation, 0.0, False, "daily_loss_limit_hit")
+ 
+         sleeve = getattr(recommendation, "sleeve", None)
+         is_core = sleeve is not None and str(sleeve.value) == "core"
+ 
+         # --- CORE DCA: fixed fractional sizing (no stop required) ---
+diff --git a/equities/risk/state.py b/equities/risk/state.py
+new file mode 100644
+index 0000000..171ae7f
+--- /dev/null
++++ b/equities/risk/state.py
+@@ -0,0 +1,35 @@
++"""Kernel state persistence: high-water mark and halt flag."""
++import json
++from pathlib import Path
++
++
++def load_kernel_state(path: Path) -> dict:
++    """Load persisted kernel state from JSON file.
++
++    Args:
++        path: Path to state file.
++
++    Returns:
++        dict with keys: high_water_mark (float), halted (bool), capital (float).
++        Empty dict if file doesn't exist or is unreadable.
++    """
++    if not path.exists():
++        return {}
++    try:
++        return json.loads(path.read_text())
++    except (json.JSONDecodeError, OSError):
++        return {}
++
++
++def save_kernel_state(path: Path, hwm: float, halted: bool, capital: float) -> None:
++    """Persist kernel state to JSON file atomically.
++
++    Args:
++        path: Path to state file.
++        hwm: High-water mark (peak equity).
++        halted: Circuit-breaker flag.
++        capital: Current capital (for validation on reload).
++    """
++    tmp = path.with_suffix(".tmp")
++    tmp.write_text(json.dumps({"high_water_mark": hwm, "halted": halted, "capital": capital}))
++    tmp.replace(path)
+diff --git a/runner_equities.py b/runner_equities.py
+index ce5cb8e..0072ff7 100644
+--- a/runner_equities.py
++++ b/runner_equities.py
+@@ -892,20 +892,21 @@ async def run_once(
+ 
+         # --- Risk kernel + paper open ---
+         kernel = RiskKernel(
+             capital=settings.bankroll_usd,
+             risk_pct=settings.equity_risk_pct,
+             max_positions=settings.equity_max_positions,
+             max_name_pct=settings.equity_max_name_pct,
+             max_sector_pct=settings.equity_max_sector_pct,
+             daily_loss_limit_pct=settings.equity_daily_loss_limit_pct,
+             drawdown_limit_pct=settings.equity_drawdown_limit_pct,
++            state_path=Path("data/kernel_state.json"),
+         )
+         open_positions = equity_ledger.open_positions()
+         sector_lookup: dict[str, str] = {}
+ 
+         def sector_for(ticker: str) -> str:
+             if ticker in sector_lookup:
+                 return sector_lookup[ticker]
+             try:
+                 sector_lookup[ticker] = fundamentals_provider.fetch(ticker).sector
+             except (RuntimeError, TimeoutError):
+diff --git a/tests/equities/test_kernel_state.py b/tests/equities/test_kernel_state.py
+new file mode 100644
+index 0000000..cd0b33b
+--- /dev/null
++++ b/tests/equities/test_kernel_state.py
+@@ -0,0 +1,55 @@
++"""Test kernel state persistence across restarts."""
++from pathlib import Path
++
++from equities.risk.kernel import RiskKernel
++
++
++class FakeRecommendation:
++    """Minimal recommendation stub for testing kernel approval."""
++
++    def __init__(self):
++        self.entry = 100.0
++        self.stop_loss = 95.0
++        self.size_pct = 0.02
++        self.sleeve = None
++
++    class Instrument:
++        ticker = "TEST"
++
++    instrument = Instrument()
++
++
++def test_high_water_mark_survives_restart(tmp_path: Path):
++    """Verify HWM persists when kernel is restarted."""
++    state = tmp_path / "kernel_state.json"
++    k1 = RiskKernel(capital=10_000, state_path=state)
++    # Simulate equity climbing to 12k via approve() with current_equity param
++    rec = FakeRecommendation()
++    k1.approve(rec, [], current_equity=12_000)
++
++    # Create new kernel with same state file — should restore HWM
++    k2 = RiskKernel(capital=10_000, state_path=state)
++    assert k2._high_water_mark == 12_000
++
++
++def test_halted_flag_survives_restart(tmp_path: Path):
++    """Verify halt flag persists when kernel is restarted."""
++    state = tmp_path / "kernel_state.json"
++    k1 = RiskKernel(capital=10_000, state_path=state)
++    rec = FakeRecommendation()
++
++    # Set HWM to 12k
++    k1.approve(rec, [], current_equity=12_000)
++
++    # Trigger halt: 10k / 12k = 16.7% drawdown (exceeds 15% default limit)
++    result = k1.approve(rec, [], current_equity=10_000)
++    assert not result.approved and "drawdown" in result.rejection_reason
++    assert k1._halted
++
++    # Create new kernel — should restore halted state
++    k2 = RiskKernel(capital=10_000, state_path=state)
++    assert k2._halted
++
++    # Verify new approval is rejected due to restored halt
++    result2 = k2.approve(rec, [], current_equity=10_000)
++    assert not result2.approved and "circuit_breaker" in result2.rejection_reason