github · tradememory-protocolHEAD

Evidence

if __name__ == "__main__":

    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=9001, reload=False)

Remediation

Bind to 127.0.0.1 for local-only access. If cross-host access is truly required, put the service behind an authenticated reverse proxy rather than exposing it on 0.0.0.0.

Evidence

def main():

    """Run hosted API server."""

    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=8080)

if __name__ == "__main__":

Remediation

Bind to 127.0.0.1 for local-only access. If cross-host access is truly required, put the service behind an authenticated reverse proxy rather than exposing it on 0.0.0.0.

Evidence

```bash

cd C:\Users\johns\projects\tradememory-protocol

.venv\Scripts\activate

uvicorn scripts.mt5_sync_v3:app --port 9001 --host 0.0.0.0

```

或用 bat 檔（含 watchdog 自動重啟）：

Remediation

Bind to 127.0.0.1 for local-only access. If cross-host access is truly required, put the service behind an authenticated reverse proxy rather than exposing it on 0.0.0.0.

Evidence

env: python

    branch: master

    buildCommand: pip install -e .

    startCommand: uvicorn hosted.server:app --host 0.0.0.0 --port $PORT

    plan: free

    envVars:

      - key: TM_HOSTED_DB

Remediation

Bind to 127.0.0.1 for local-only access. If cross-host access is truly required, put the service behind an authenticated reverse proxy rather than exposing it on 0.0.0.0.

Evidence

echo [%date% %time%] Launching uvicorn scripts.mt5_sync_v3:app ...

echo [%date% %time%] Launching uvicorn ... >> "%LOG_DIR%\mt5_sync_v3_start.log"

uvicorn scripts.mt5_sync_v3:app --port 9001 --host 0.0.0.0

echo [%date% %time%] uvicorn exited (code: %ERRORLEVEL%). Restarting in 30s... >> "%LOG_DIR%\mt5_sync_v3_start.log"

echo [%date% %time%] uvicorn exited. Restarting in 30s...

Remediation

Bind to 127.0.0.1 for local-only access. If cross-host access is truly required, put the service behind an authenticated reverse proxy rather than exposing it on 0.0.0.0.

Evidence

)

        if response.status_code != 200:

            print(f"[ERROR] API request failed: {response.status_code}")

            print(response.text)

            return None

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

return True

    except requests.exceptions.RequestException as e:

        print(f"[ERROR] API request failed for {trade_id}: {e}")

        return False

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

)

        if response.status_code != 200:

            print(f"[ERROR] API request failed: {response.status_code}")

            print(response.text)

            return None

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

)

        if response.status_code != 200:

            print(f"[ERROR] API request failed: {response.status_code}")

            print(response.text)

            return None

Remediation

Strip C0/C1 control codes before printing user-controlled values. Python: re.sub(r"[\x00-\x08\x0b-\x1f\x7f]", "", s). Prefer a structured logger (json/logfmt) over raw print to stdout.

Evidence

print(f"\n  LLM ERROR: {e}")

        print(f"  This might be a rate limit or API issue.")

        await llm.close()

        return {"error": str(e)}

    except Exception as e:

        print(f"\n  UNEXPECTED ERROR: {type(e).__name__}: {e}")

        import traceback

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

else:

            return {"error": f"Unsupported trade log format: {format}", "disclaimer": DISCLAIMER}

    except (FileNotFoundError, ValueError) as e:

        return {"error": str(e), "disclaimer": DISCLAIMER}

    if not trades:

        return {"error": "No valid trades parsed from CSV", "disclaimer": DISCLAIMER}

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

except FileNotFoundError as e:

        return {"error": str(e), "hint": "Provide the full absolute path to your CSV file."}

    except ValueError as e:

        return {"error": str(e)}

    except Exception as e:

        logger.error("validate_strategy failed: %s", e)

        return {"error": f"Validation failed: {e}"}

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

import traceback

        traceback.print_exc()

        await llm.close()

        return {"error": str(e)}

    elapsed = time.time() - start_time

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

num_strategies=num_strategies,

            )

    except FileNotFoundError as e:

        return {"error": str(e), "hint": "Provide the full absolute path to your CSV file."}

    except ValueError as e:

        return {"error": str(e)}

    except Exception as e:

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

}

    except Exception as e:

        logger.warning("DSR computation failed: %s", e)

        return {"verdict": "ERROR", "error": str(e)}

async def run_full_experiment(

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

try:

        tf = _resolve_timeframe(timeframe)

    except ValueError as e:

        return {"error": str(e)}

    # Get data

    if series is None:

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

except Exception as e:

        print(f"  ERROR fetching from Binance: {e}")

        await binance.close()

        return {"error": str(e)}

    await binance.close()

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

return compute_dsr(sharpe_raw=sharpe, num_obs=n_trades, num_trials=1)

        return {"verdict": "INSUFFICIENT_DATA", "sharpe_raw": round(sharpe, 6)}

    except Exception as e:

        return {"verdict": "ERROR", "error": str(e)}

# ---------------------------------------------------------------------------

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

except LLMError as e:

        print(f"\n  LLM ERROR: {e}")

        await llm.close()

        return {"error": str(e)}

    except Exception as e:

        print(f"\n  UNEXPECTED ERROR: {type(e).__name__}: {e}")

        import traceback

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

import traceback

        traceback.print_exc()

        await llm.close()

        return {"error": str(e)}

    elapsed = time.time() - start_time

Remediation

Log the full exception server-side with a correlation ID; return only {"error_id": id, "message": "internal error"} to the caller. Never enable Flask debug mode in production.

Evidence

或用 Python：

```python

import requests

r = requests.get('http://localhost:8000/trade/get_active')

print(r.json())

```

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

- tradememory-data:/app/data

    restart: unless-stopped

    healthcheck:

      test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/api/v1/health')"]

      interval: 30s

      timeout: 5s

      retries: 3

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

Args:

        symbols: List of trading pairs (default: ["BTCUSDT", "ETHUSDT"])

        timeframes: List of bar timeframes (default: ["15m", "1h", "4h"])

        days: Days of historical data to fetch (default: 1095 = 3 years)

        is_ratio: In-sample ratio for IS/OOS split (default: 0.67)

        output_dir: Directory for output files

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

```python

# Today's reflection

resp = requests.post("http://localhost:8000/reflect/run_daily")

print(resp.json()["summary"])

# Specific date

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

**Example (Python):**

```python

resp = requests.get("http://localhost:8000/trade/get_active")

active = resp.json()["trades"]

print(f"{len(active)} open positions")

```

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

url.searchParams.set(key, value);

    }

  }

  const res = await fetch(url.toString());

  if (!res.ok) {

    throw new Error(`API error ${res.status}: ${res.statusText}`);

  }

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

Args:

        symbol: Trading pair (e.g. "BTCUSDT", "ETHUSDT")

        timeframe: Bar timeframe — "5m", "15m", "1h", "4h", "1d"

        days: Number of days of history to fetch (default 90)

    """

    from .evolution.mcp_tools import fetch_market_data

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

print(resp.json()["summary"])

# Specific date

resp = requests.post("http://localhost:8000/reflect/run_daily?date=2026-02-22")

```

---

Remediation

Pass timeout= on every call: - HTTP: `requests.get(url, timeout=5)`, `httpx.get(url, timeout=5.0)` - Node fetch: `AbortSignal.timeout(5000)` - Subprocess: `subprocess.run(["cmd"], timeout=30, check=True)` Pick a value short enough to fail fast and retry.

Evidence

FROM python:3.11-slim

WORKDIR /app

COPY pyproject.toml README.md LICENSE ./

COPY src/ ./src/

RUN pip install --no-cache-dir .

ENTRYPOINT ["tradememory-protocol"]

Remediation

Create and switch to a non-root user before the CMD / ENTRYPOINT: RUN adduser --system --uid 1000 app USER 1000 Or reuse the base image's shipped non-root account (e.g. `USER nobody`, `USER nonroot` on distroless). Multi-stage builds only need the USER directive in the final stage.

Evidence

- uses: actions/checkout@v4

      - name: Set up Python

        uses: actions/setup-python@v5

        with:

          python-version: "3.12"

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

- uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}

        uses: actions/setup-python@v5

        with:

          python-version: ${{ matrix.python-version }}

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

environment: pypi

    steps:

      - uses: actions/checkout@v4

      - name: Set up Python

        uses: actions/setup-python@v5

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

python-version: ["3.10", "3.11", "3.12"]

    steps:

      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}

        uses: actions/setup-python@v5

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

- uses: actions/checkout@v4

      - name: Set up Python 3.12

        uses: actions/setup-python@v5

        with:

          python-version: '3.12'

          cache: 'pip'

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

run: python -m build

      - name: Publish to PyPI

        uses: pypa/gh-action-pypi-publish@release/v1

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

timeout-minutes: 5

    steps:

      - uses: actions/checkout@v4

      - name: Set up Python 3.12

        uses: actions/setup-python@v5

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

- name: Notify on failure

        if: failure()

        uses: actions/github-script@v7

        with:

          script: |

            core.error('Live executor failed. Check the workflow run for details.')

Remediation

Pin every `uses:` to a 40-character commit SHA. Trailing comment with the version helps reviewers: `uses: actions/checkout@8e5e7e5ab8b370d6c329ec480221332ada57f0ab # v4.1.1` Automate the migration with `pinact` (https://github.com/suzuki-shunsuke/pinact) or `ratchet` (https://github.com/sethvargo/ratchet). Add a `pinact run --check` pre-commit hook so future PRs stay pinned. Re-pin when the action releases a new version — Dependabot can do this automatically with `version-update-strategy: inc

Evidence

last = {}

    if last_line:

        try:

            last = json.loads(last_line)

        except Exception:

            pass

    # Trade count from DB

    trades = 0

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"timestamp": datetime.now(timezone.utc).isoformat(),

            }]

        }

        requests.post(DISCORD_WEBHOOK_URL, json=payload, timeout=5)

    except Exception:

        pass

def recall_similar(symbol: str, strategy: str, session: str) -> List[Dict]:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

cp = {}

    if CHECKPOINT.exists():

        try:

            cp = json.loads(CHECKPOINT.read_text())

        except Exception:

            pass

    return decisions, last, trades, total_pnl, wins, cp

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if procs:

                kelly = procs[0].get("kelly_fraction_suggested")

                if kelly and kelly > 0:

                    lot = min(lot, kelly)

        except Exception:

            pass  # No procedural memory yet — use DQS-adjusted lot

        if lot <= 0:

            self.skipped_signals += 1

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"timestamp": datetime.now(timezone.utc).isoformat(),

            }]

        }

        requests.post(DISCORD_WEBHOOK_URL, json=payload, timeout=5)

    except Exception:

        pass

# ---------------------------------------------------------------------------

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

log.warning(f"{consecutive_errors} consecutive errors, attempting MT5 reconnect...")

                    try:

                        import MetaTrader5 as MT5

                        MT5.shutdown()

                    except Exception:

                        pass

                    if init_mt5():

                        log.info("MT5 reconnected successfully.")

                        consecutive_errors = 0

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"avg_conf": avg_conf,

                        "avg_aff": avg_aff,

                        "negative_ratio": negative_ratio,

                    })

        except Exception:

            pass  # PG unavailable — silently skip, recall still works

        return response

    except Exception as e:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

proposed_lot_size=agent.fixed_lot,

                    context_regime=None,

                )

                is_dqs_scores.append(dqs.score)

            except Exception:

                pass

        # Step 3: Set adaptive thresholds from IS distribution

        if is_dqs_scores:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

beliefs = [

            f"{b.get('proposition', '')} (conf={b.get('confidence', 0):.2f})"

            for b in sem

        ]

    except Exception:

        pass

    from .domain.tdr import MemoryContext

    mem = MemoryContext(

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try:

                    conn.execute(

                        "ALTER TABLE episodic_memory ADD COLUMN embedding TEXT"

                    )

                except Exception:

                    pass  # Column already exists

                embedding_json = json.dumps(embedding)

                result = conn.execute(

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

beliefs = [

            f"{b.get('proposition', '')} (conf={b.get('confidence', 0):.2f})"

            for b in sem

        ]

    except Exception:

        pass

    mem = MemoryContext(

        similar_trades=refs,

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"""Shutdown + re-init MT5."""

        try:

            import MetaTrader5 as MT5

            MT5.shutdown()

        except Exception:

            pass

        return self.init_mt5()

    # --- Open positions → SQLite ---

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"timestamp": datetime.now(timezone.utc).isoformat(),

            }]

        }

        requests.post(DISCORD_WEBHOOK_URL, json=payload, timeout=5)

    except Exception:

        pass  # Never fail the script for a notification issue

def generate_daily_reflection(target_date: date = None) -> str:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

m = _SL_COMMENT_RE.search(comment)

    if m:

        try:

            return float(m.group(1))

        except ValueError:

            pass

    return None

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Clean up

    try:

        os.unlink(db_path)

        os.rmdir(tmp)

    except OSError:

        pass

    return sections

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Clean up partial file

    try:

        if os.path.exists(partial_path):

            os.remove(partial_path)

    except Exception:

        pass

    return {

        "total_experiments": len(all_results),

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Partial save after each experiment

                try:

                    with open(partial_path, "w") as f:

                        json.dump(all_results, f, indent=2, default=str)

                except Exception:

                    pass

    # Generate final report

    report_obj = FullExperimentReport(results=all_results)

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

log.warning("MT5 health check failed, attempting reconnect...")

                    try:

                        import MetaTrader5 as MT5

                        MT5.shutdown()

                    except Exception:

                        pass

                    if init_mt5():

                        log.info("MT5 reconnected after health check failure.")

                    else:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

expiry_dt = expiry_dt.replace(tzinfo=timezone.utc)

                if now > expiry_dt:

                    db.update_prospective_status(plan["id"], "expired")

                    continue

            except (ValueError, TypeError):

                pass

        # Check trigger_condition against context

        trigger_cond = plan.get("trigger_condition", {})

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Try raw JSON first

        try:

            return json.loads(text)

        except json.JSONDecodeError:

            pass

        # Try extracting from markdown code block

        if "```" in text:

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

proposed_lot_size=agent.fixed_lot,

                context_regime=None,

            )

            is_dqs_scores.append(dqs.score)

        except Exception:

            pass

    if is_dqs_scores:

        agent.dqs_engine.set_adaptive_thresholds(is_dqs_scores)

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"FROM episodic_memory"

            ).fetchone()

            trades, total_pnl, wins = row[0], row[1], row[2] or 0

            conn.close()

        except Exception:

            pass

    # Checkpoint

    cp = {}

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"timestamp": datetime.now(timezone.utc).isoformat(),

            }]

        }

        requests.post(DISCORD_WEBHOOK_URL, json=payload, timeout=5)

    except Exception:

        pass  # Never block sync for a notification failure

# Setup logging to both file and console

os.makedirs("logs", exist_ok=True)

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try:

        resp = requests.get(f"{TRADEMEMORY_API}/owm/state", timeout=10)

        if resp.status_code == 200:

            return resp.json()

    except Exception:

        pass

    return None

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try:

        resp = requests.get(f"{TRADEMEMORY_API}/owm/behavioral", timeout=10)

        if resp.status_code == 200:

            return resp.json()

    except Exception:

        pass

    return None

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if procs:

                    kelly = procs[0].get("kelly_fraction_suggested")

                    if kelly and kelly > 0:

                        lot = min(lot, kelly)

            except Exception:

                pass

        if lot <= 0:

            self.skipped_signals += 1

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

"timestamp": _now_iso(),

            }]

        }

        requests.post(DISCORD_WEBHOOK_URL, json=payload, timeout=5)

    except Exception:

        pass

# ---------------------------------------------------------------------------

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

ts = float(value)

        if ts > 1e12:

            ts /= 1000  # milliseconds

        return datetime.fromtimestamp(ts, tz=timezone.utc)

    except (ValueError, OSError):

        pass

    return None

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

ctx = json.loads(market_context)

            s = ctx.get("session", "").lower()

            if s in ("asia", "london", "ny", "newyork", "new_york"):

                return {"newyork": "NY", "new_york": "NY"}.get(s, s.capitalize())

        except (json.JSONDecodeError, AttributeError):

            pass

    # Fallback: infer from UTC hour

    try:

        dt = datetime.fromisoformat(ts_str.replace("Z", "+00:00"))

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

data = resp.json()

            memories = data.get("memories", [])

            # Double-check: only keep same strategy (in case API doesn't filter)

            return [m for m in memories if m.get("strategy") == strategy]

    except Exception:

        pass

    return []

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

import MetaTrader5 as MT5

        info = MT5.symbol_info(symbol)

        if info and info.trade_contract_size > 0:

            return info.trade_contract_size

    except Exception:

        pass

    return _CONTRACT_SIZES.get(symbol, 100000)

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

dt = datetime.fromisoformat(t["timestamp"].replace("Z", "+00:00"))

            dow = dt.weekday()

            if dow < 5:

                session_day[(sess, day_names[dow])].append(t["pnl"])

        except Exception:

            pass

    heatmap = []

    for (sess, day), pnls in sorted(session_day.items()):

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if sys.platform == "win32":

    try:

        sys.stdout.reconfigure(encoding="utf-8")

    except Exception:

        pass

# ---------------------------------------------------------------------------

# Config (.env)

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

content = filepath.read_text(encoding='utf-8')

            # Extract date from filename: reflection_weekly_2026-02-23.txt

            date_str = filepath.stem.replace("reflection_weekly_", "")

            reflections.append({'date': date_str, 'content': content})

        except Exception:

            pass

    return reflections[:weeks]

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

expiry_dt = expiry_dt.replace(tzinfo=timezone.utc)

                    if now > expiry_dt:

                        db.update_prospective_status(plan["id"], "expired")

                        continue

                except (ValueError, TypeError):

                    pass

            trigger_cond = plan.get("trigger_condition", {})

            if isinstance(trigger_cond, str):

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

content = filepath.read_text(encoding='utf-8')

            # Extract month from filename: reflection_monthly_2026-02.txt

            month_str = filepath.stem.replace("reflection_monthly_", "")

            reflections.append({'month': month_str, 'content': content})

        except Exception:

            pass

    return reflections[:months]

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Reconfigure stdout for Windows UTF-8

if sys.platform == "win32":

    try:

        sys.stdout.reconfigure(encoding="utf-8")

    except Exception:

        pass

# ---------------------------------------------------------------------------

# Setup paths — ensure tradememory package is importable

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

if dqs.tier == "skip":

                    self.skipped_signals += 1

                    return None

                lot *= dqs.position_multiplier

            except Exception:

                pass

        else:

            self._last_dqs_score = 10.0

            self._last_dqs_tier = "go"

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

# Cleanup partial

    if os.path.exists(partial_path):

        try:

            os.remove(partial_path)

        except Exception:

            pass

    print(f"\nResults: {output_base}.json")

    print(f"Report:  {output_base}.md")

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

save_state(last_synced_ticket)

        try:

            import MetaTrader5 as MT5

            MT5.shutdown()

        except Exception:

            pass

        log.info(f"Final state saved: last_ticket={last_synced_ticket}. Goodbye!")

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

metrics = {}

        if p.get("metrics"):

            try:

                metrics = json.loads(p["metrics"])

            except (json.JSONDecodeError, TypeError):

                pass

        conf = p.get("confidence", 0.5)

        # Derive alpha/beta from confidence and sample_size

Remediation

Log the exception at minimum (`logger.exception(e)`), emit a metric, or re-raise if the error is not recoverable. If you genuinely want to ignore an exception, say so with a comment.

Evidence

try:

                float(parts[1].strip())

                _parse_date(parts[0].strip())

                is_data = True