Trade Scan

Trade Scan

Full pipeline execution: discovery layer + 6 stages + 5 validation hooks + mandatory human approval. Minervini + PTJ risk model.

Commands

• /trade-scan — full discovery (all 3 modes) + pipeline on top candidates
• /trade-scan TICKER — skip discovery, run pipeline directly on a specific ticker
• /trade-scan --sector XLK — sector-focused discovery + pipeline on top names

Reference Files

• ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs — deterministic validation script for hooks 1, 4, and preflight
• ${CLAUDE_PLUGIN_ROOT}/skills/shared/tool-map.md — MCP tool names, parameters, response shapes
• ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/ — regime-adaptive and specialized prompt templates
• ~/trading-journal/ — daily journals, scorecards, watchlist, snapshots

Validation Script

validate.mjs enforces all deterministic checks with code. Claude MUST call it for hooks 1, 4, position sizing, and preflight — and MUST use its output as the authoritative result. Claude cannot override a HALT from the script.

Commands:

• hook1 — market context thresholds, exposure ceiling, tighten-only ratchet
• position_size — Minervini formula, R:R, exposure, direction-aware math
• hook4 — 1% risk cap, 5% circuit breaker, position limit, R:R gate
• preflight — all 7 live recomputation checks before execution

Usage: node ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs '<JSON>'

Checkpoint Protocol

After EVERY hook (1-5) and after preflight, output this checkpoint block before continuing:

----- HOOK N CHECKPOINT -----
Source: SCRIPT | LLM | SCRIPT+LLM
State:  PROCEED | PROCEED_WITH_FLAGS | NO_NEW_EXPOSURE | HALT
Reason: [one line]
Flags:  [list or "none"]
Gate:   PASS | FAIL
------------------------------

• Hooks 1, 4, Preflight: Source = SCRIPT. Paste the script's JSON output, then the checkpoint.
• Hooks 2, 3: Source = SCRIPT+LLM (script handles any deterministic checks, LLM handles qualitative assessment)
• Hook 5: Source = LLM (adversarial challenge is purely LLM inference)

If Gate = FAIL, STOP. Do not continue to the next stage. Explain why to the user.

Initialization

On first run, create these if they don't exist:

~/trading-journal/
  watchlist.json          (empty array: [])
  scorecards.json         (see Darwinian Weighting section)
  snapshots/              (empty directory)

---

Pipeline Overview

DISCOVERY LAYER (if no ticker specified)
  -> Stage 0: Morning Scan
  -> Stage 1: Market Context
  -> Hook 1: Context Validator
  -> Stage 2: Signal Generation
  -> Hook 2: Signal Coherence
  -> Stage 3: Fundamental Check (equities only)
  -> Hook 3: Fundamental Sanity (equities only)
  -> Stage 4: Risk + Position Sizing
  -> Hook 4: Risk Guardrails
  -> Stage 4b: Adversarial Challenge
  -> Hook 5: Adversarial Gate
  -> Stage 5: Proposal -> Human Approval -> Preflight -> Execute

Hook State Enum

All hooks output exactly one of these states. No synonyms.

State	Meaning	Pipeline behavior
PROCEED	All checks passed	Continue to next stage
PROCEED_WITH_FLAGS	Passed with warnings	Continue, surface flags in proposal card
NO_NEW_EXPOSURE	Market conditions prohibit new entries	Block new entries; allow closing existing positions only
HALT	Hard failure	Stop pipeline, surface reason, no trade

Tighten-Only Ratchet

Sentiment inference can escalate constraints upward but NEVER loosen them:

final_constraint = max(metric_restriction, sentiment_restriction)

If metrics say PROCEED but sentiment says NO_NEW_EXPOSURE -> final is NO_NEW_EXPOSURE. If metrics say NO_NEW_EXPOSURE but sentiment says PROCEED -> final is NO_NEW_EXPOSURE.

The ratchet only tightens. This is non-negotiable.

---

Discovery Layer

Skip this section entirely if the user specified a ticker (/trade-scan AAPL).

Mode 1: Universe Screener (Minervini Trend Template)

1. Call mcp__tradingview__rating_filter with exchange: "NASDAQ", rating: "strong_buy" to get initial universe
2. For the top 20 results, call mcp__tradingview__combined_analysis per ticker
3. Filter by Minervini SEPA criteria:
   • Price > 150-day MA > 200-day MA (confirmed uptrend)
   • 200-day MA trending up for >= 1 month
   • Price within 25% of 52-week high
   • Price >= 30% above 52-week low
   • Relative strength vs S&P 500 >= 70th percentile
   • Volume on up days > volume on down days (accumulation)
4. Post-filter: discard anything with earnings within 5 days
5. Output: ~20-50 names passing trend template

Mode 2: Sector Rotation (Regime-Aware)

1. Scan 11 sector ETFs: XLK, XLE, XLF, XLV, XLI, XLC, XLY, XLP, XLU, XLRE, XLB
2. For each ETF, call mcp__tradingview__combined_analysis to get price data
3. Rank each by relative strength vs SPY across 3 windows:
   • 1-month RS (weight 0.5)
   • 3-month RS (weight 0.3)
   • 6-month RS (weight 0.2)
4. Apply regime filter:
   • BULL: top 3 sectors
   • CORRECTION: top 2, bias toward defensive (XLV, XLP, XLU)
   • BEAR: top 1, defensive only
   • CRISIS: skip sector rotation entirely
5. For winning sectors: scan top 10 holdings with combined_analysis
6. Output: ~20-30 names from leading sectors

Mode 3: Watchlist (User-Curated)

1. Read watchlist from ${CLAUDE_PLUGIN_ROOT}/watchlist/ directory (e.g., dated JSON files)
2. For each watchlist ticker, call mcp__tradingview__combined_analysis
3. Check triggering conditions:
   • Price breaking above breakout_level
   • Volume spike > 1.5x 20-day average
   • RSI crossing out of oversold (< 30 -> above)
   • Multi-timeframe alignment shift (call mcp__tradingview__multi_timeframe_analysis)
4. Output: watchlist names with triggered alerts

Merge + Rank

1. Deduplicate across all 3 modes
2. Score each candidate:
   • +3 appeared in multiple modes (convergence)
   • +2 watchlist alert just triggered (timing)
   • +2 in top sector by regime-adjusted RS
   • +1 Minervini trend template pass
   • +1 volume surge today
   • -1 earnings within 5 days (binary event risk)
3. Regime gate:
   • BULL: top 5
   • CORRECTION: top 3
   • BEAR: top 2 (A+ only)
   • CRISIS: 0 (discovery halts)
4. Present discovery report card:

DISCOVERY REPORT -- YYYY-MM-DD (Regime: REGIME)
================================================
Universe screener: N passed Minervini template
Sector leaders:    SECTOR1 (+X.X% RS), SECTOR2 (+X.X% RS)
Watchlist alerts:  TICKER (reason), TICKER (reason)

TOP N CANDIDATES (entering pipeline):
 #1  TICKER  score: N  [sources]
 #2  TICKER  score: N  [sources]
 ...

Proceed with pipeline on all N? [yes / pick / skip]

5. Wait for human confirmation before running pipeline on candidates.

---

Stage 0: Morning Scan

Runs once per session (pre-market preferred). Sets morning_context for all subsequent stages.

Steps

1. Call mcp__tradingview__financial_news for broad market headlines
2. Call mcp__tradingview__market_sentiment for key tickers (SPY, QQQ) to gauge social buzz
3. If news tool returns empty: note the gap, continue with available data

Claude Inference

Read the raw headlines and classify each:

INPUT: headlines[] from financial_news + market_sentiment

CLASSIFY each item:
1. Category: macro | political | sector | company | noise
2. Market impact: NONE | LOW | MEDIUM | HIGH | CRITICAL
3. Affected scope: broad_market | sector(s) | ticker(s)
4. Directional bias: bullish | bearish | uncertain

OUTPUT morning_context:
  events: [{event, category, impact, scope, bias, source}]
  high_impact_events: [filtered to MEDIUM+ only]
  affected_sectors: [sector list]
  affected_tickers: [ticker list]
  recommended_state_escalation: PROCEED | PROCEED_WITH_FLAGS | NO_NEW_EXPOSURE | HALT

Load the sentiment analysis prompt from ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/sentiment-analysis.md.

Escalation Rules

Event Type	Example	Escalation
Routine news	"AAPL beats Q2"	PROCEED
Policy shift	"New tariffs on semis"	PROCEED_WITH_FLAGS
Broad shock	War escalation, surprise rate hike	NO_NEW_EXPOSURE
Black swan	Market-wide halt, systemic event	HALT

State Output

Store morning_context for use in Stage 1 and all hooks via the tighten-only ratchet.

Event Alert (Mid-Session Interrupt)

If a scan during ANY pipeline stage surfaces a high-impact headline that wasn't in the morning scan:

1. Pause the current stage
2. Assess: is this market-moving? What's the blast radius?
3. Apply the same classification and escalation logic as Morning Scan
4. Update morning_context with the new event
5. Apply tighten-only ratchet — the new event can only escalate constraints, never loosen them
6. If escalation changes the pipeline state (e.g., PROCEED -> NO_NEW_EXPOSURE):
   • For the current ticker: re-evaluate from the last hook with the new constraint
   • For subsequent tickers: they inherit the updated morning_context automatically

Event Alerts are NOT a separate stage — they interrupt the pipeline at whatever stage is running. The ratchet ensures they can only make things more cautious.

---

Stage 1: Market Context

Steps

1. Call mcp__tradingview__market_snapshot — get indices, VIX, sector ETFs
2. Call mcp__alpaca__get_clock — check if market is open
3. Call mcp__alpaca__get_all_positions — get current exposure
4. Merge morning_context from Stage 0

Regime Detection

Classify current market regime from snapshot data:

Regime	Criteria
BULL	SPY > 200MA, VIX < 20, breadth expanding
CORRECTION	SPY > 200MA, VIX 20-30, breadth narrowing
BEAR	SPY < 200MA, VIX > 25
CRISIS	VIX > 35, multiple circuit breaker events
RECOVERY	SPY crossing back above 200MA from below, VIX declining

Load the active regime prompt from ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/regime-{regime}.md.

Regime Blending

If the regime changed within the last 5 trading days, blend old and new regime prompts:

Day 1: 50/50 -> Day 2: 40/60 -> Day 3: 30/70 -> Day 4: 20/80 -> Day 5: 10/90 -> new regime only

Tracking Transitions Across Sessions

Record regime transitions in the daily journal's Market Context section:

Regime: CORRECTION (day 3 of transition from BULL)
Blend: BULL 30% / CORRECTION 70%

To determine day_in_transition: check previous daily journals for the last regime change entry. If no prior journal exists or no transition is recorded, treat the current regime as fully active (no blending). The journal is the source of truth for transition state — not memory.

State Output

market_context:
  regime: BULL | CORRECTION | BEAR | CRISIS | RECOVERY
  spy_price: float
  spy_vs_200ma: above | below
  vix: float
  exposure_ceiling: 25% | 50% | 100%
  current_exposure: float (from positions)
  open_positions: int
  morning_context_escalation: PROCEED | PROCEED_WITH_FLAGS | NO_NEW_EXPOSURE | HALT

---

Hook 1: Context Validator

Deterministic only — no LLM inference.

Apply the tighten-only ratchet: merge metric-based constraints with sentiment-based escalation. Take the MORE restrictive of the two.

Check	Condition	Action
SPY below 200-day MA	PTJ defense	Exposure ceiling -> 25%
SPY above 200MA, VIX > 25	Elevated fear	Exposure ceiling -> 50%
Normal (SPY > 200MA, VIX < 25)	Risk-on	Exposure ceiling -> 100%
Market closed + equities	Off-hours	Warn, allow next-open planning
TradingView data failure	No market snapshot	NO_NEW_EXPOSURE

Run the validation script:

node ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs '{"command":"hook1","spy_price":<SPY>,"spy_200ma":<200MA>,"vix":<VIX>,"sentiment_escalation":"<MORNING_CONTEXT_ESCALATION>"}'

The script computes the exposure ceiling and applies the tighten-only ratchet. Its output is authoritative — do not override.

Decision: Use the script's state field. If HALT or NO_NEW_EXPOSURE -> stop pipeline, explain why. Do not proceed to Stage 2.

---

Stage 2: Signal Generation (per ticker)

Stages 2-5 run ONCE PER CANDIDATE TICKER. If discovery produced 3 candidates, each gets its own full pipeline pass through Stages 2-5 sequentially. Stages 0-1 and Hook 1 ran once for the session and their outputs (morning_context, market_context, exposure_ceiling) are shared across all candidates.

Steps

1. Call mcp__tradingview__combined_analysis with symbol, exchange — primary TA + sentiment + news
2. Call mcp__tradingview__multi_timeframe_analysis with symbol, exchange — 5-timeframe analysis
3. Call mcp__tradingview__volume_confirmation_analysis with symbol, exchange — volume confirmation
4. Call mcp__tradingview__market_sentiment with symbol — social buzz

Claude Inference

Load ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/signal-generation.md and the active ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/regime-{regime}.md.

Synthesize all inputs into a signal assessment. Apply Darwinian weights from ~/trading-journal/scorecards.json:

weighted_signal = S (source_signal x source_weight) / S (source_weight)

If scorecards.json doesn't exist or has fewer than 10 scored trades per source, use equal weights (1.0).

Ticker Enrichment (News Alignment)

From the combined_analysis response, extract the news field. Classify:

• CONFIRMING — news supports the technical signal direction
• NEUTRAL — no relevant news or mixed
• CONTRADICTING — news opposes the technical signal

State Output

signal:
  ticker: string
  direction: LONG | SHORT
  signal_strength: float (0-1, Darwinian-weighted)
  conviction: HIGH | MEDIUM | LOW
  timeframe_alignment: N/5
  confirming_signals: [list of signal names]
  news_alignment: CONFIRMING | NEUTRAL | CONTRADICTING
  darwinian_weights: {source: weight, ...}
  regime: current regime name
  regime_context: loaded from regime prompt

---

Hook 2: Signal Coherence

Deterministic Checks

Check	Condition	Action
Timeframe alignment	< 3 of 5 aligned	HALT
Confirming signals	< 2 technical signals	HALT
Earnings proximity	Within 5 days	Flag: "binary event risk, consider half-size"
Signal vs market context	Hook 1 = NO_NEW_EXPOSURE + new entry signal	HALT

LLM Inference: Conflict Assessment

Load ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/conflict-assessment.md.

When signals, news, and patterns don't all agree, produce:

conflict_assessment:
  supports_long: [list of supporting evidence]
  supports_short: [list of opposing evidence]
  contradictions: [specific conflicts identified]
  confidence: high | medium | low
  missing_evidence: [data gaps noted]
  recommendation: PROCEED | PROCEED_WITH_FLAGS | HALT
  rationale: "explanation for human"

The recommendation field can escalate to PROCEED_WITH_FLAGS or HALT based on qualitative conflicts, but CANNOT override deterministic gates (signal count, earnings date).

Decision: PROCEED / PROCEED_WITH_FLAGS / HALT

---

Stage 3: Fundamental Check (Equities Only)

Skip entirely for crypto. Tag crypto trades as "technical-only, no fundamental backing."

Steps

1. Call mcp__edgartools__edgar_company with ticker — profile, financials, recent filings
2. Call mcp__edgartools__edgar_ownership with ticker — insider transactions
3. Call mcp__edgartools__edgar_trends with ticker + "revenue" — revenue trend
4. If deeper analysis needed: call mcp__edgartools__edgar_filing and mcp__edgartools__edgar_read for specific filings

Deterministic Checks

Check	Condition	Action
Revenue declining 2+ quarters	Deteriorating fundamentals	Flag: "technical-only trade"
Insider selling	> 3 transactions in 30 days	Flag: "heavy insider selling"
Data unavailable	Can't pull fundamentals	Tag: "technical-only, no fundamental backing"

LLM Inference: Fundamental Memo

When filing text is available, produce:

fundamental_memo:
  filing_sources: ["10-K 2025", "10-Q Q3 2025", ...]
  quantitative_flags: [from metric checks above]
  qualitative_flags:
    - {finding: "description", filing: "source", severity: low|medium|high}
  cross_document_issues: [inconsistencies between filings]
  evidence_confidence: high | medium | low
  overall_assessment: "Fundamentals support thesis / mixed / red flags"
  recommendation: PROCEED | PROCEED_WITH_FLAGS | HALT

State Output

Attach fundamental_memo to pipeline state.

---

Hook 3: Fundamental Sanity

Deterministic Gate

• manipulation_confidence = high -> HALT (non-negotiable, LLM cannot override)

LLM Recommendation

The fundamental_memo's recommendation can escalate:

• PROCEED_WITH_FLAGS — minor qualitative concerns, surface in proposal card
• HALT — major red flags (unusual disclosures, cross-document inconsistencies)

Cannot downgrade a deterministic HALT.

Decision: PROCEED / PROCEED_WITH_FLAGS / HALT

---

Stage 4: Risk + Position Sizing

All deterministic. No LLM inference. Script-enforced.

Data Gathering

1. Call mcp__alpaca__get_account_info — equity, buying power
2. Call mcp__alpaca__get_all_positions — current positions, exposure

Position Sizing (Minervini Formula)

Run the validation script:

node ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs '{"command":"position_size","account_equity":<EQUITY>,"entry_price":<ENTRY>,"stop_price":<STOP>,"target_price":<TARGET>,"direction":"LONG|SHORT","asset_class":"equity|crypto","buying_power":<BP>,"exposure_ceiling":<CEIL>,"existing_exposure":<EXISTING_NOTIONAL>,"consecutive_losses":<N>}'

The script computes: position size (direction-aware), Phase 1/2 split, R:R, exposure, and all threshold checks. Its sizing output is the authoritative result — do not recalculate manually.

Entry Strategy (Progressive Exposure)

• Phase 1: Enter 50% of calculated position size (0.5% account risk)
• Phase 2: Add remaining 50% only if price moves 1R in favor. ALL 7 checks must pass before placing the add-on order:
  1. Move Phase 1 stop to breakeven BEFORE adding — this locks Phase 1 risk at $0
  2. Calculate Phase 2 stop: original stop distance applied from Phase 2 entry price
  3. Blended risk check:

     blended_risk = phase2_shares x phase2_stop_distance
     (Phase 1 risk is now $0 since stop is at breakeven)
     ASSERT blended_risk <= account_equity x 0.01
     

  4. Re-fetch buying power: mcp__alpaca__get_account_info

     phase2_notional = phase2_shares x live_price
     ASSERT phase2_notional <= available_buying_power
     

  5. Re-check open positions: mcp__alpaca__get_all_positions -> still < 5
  6. Re-check daily P&L -> circuit breaker not triggered
  7. Re-check exposure ceiling:

     existing_notional = sum(qty x current_price for all open positions)
     new_exposure_pct = (phase2_notional + existing_notional) / account_equity
     ASSERT new_exposure_pct <= exposure_ceiling
     

  If ANY check fails -> do not add Phase 2, keep Phase 1 only.
• Phase 3: Scale out 50% at +2R, move stop to breakeven on remainder

Adjustments

• After 2 consecutive losses -> halve position size (0.5% risk)
• After 3 consecutive losses -> HALT for the day
• Hook 1 exposure ceiling caps total exposure

R:R Checks

R:R	Action
< 1.5:1	HALT ("unfavorable R:R")
1.5-2:1	Flag: "below PTJ standard, acceptable"
>= 2:1	PROCEED
>= 5:1	Flag: "PTJ-grade setup"

Soft Checks (Warnings)

• Backtest negative expectancy -> Flag
• Stop > 8% from entry -> Flag
• 3+ positions in same sector -> Flag concentration risk
• Transaction costs erode R:R below 1.5:1 -> Flag

State Output

risk_assessment:
  position_size: int (Phase 1 -- 50% of target)
  full_target_size: int (Phase 1 + Phase 2)
  entry_price: float
  stop_loss: float
  target_price: float
  risk_amount: float
  risk_pct: float
  rr_ratio: float
  exposure_after_trade: float
  exposure_ceiling: float
  consecutive_losses: int
  flags: [list of warnings]

---

Hook 4: Risk Guardrails

All deterministic. Enforced by validation script — no LLM inference.

Run the validation script:

node ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs '{"command":"hook4","account_equity":EQUITY,"trade_risk":RISK_AMOUNT,"open_positions":COUNT,"daily_pnl":PNL,"rr":RR,"sector_positions":SECTOR_COUNT}'

Hard Limits (HALT if any triggered)

• Single trade risk > 1% of account equity -> HALT
• Total open positions >= 5 -> HALT
• Daily realized loss >= 5% of account -> HALT (circuit breaker)
• R:R < 1.5:1 -> HALT

Soft Limits (Flag)

• 3+ positions in same sector -> PROCEED_WITH_FLAGS

Parse the script output. If state is HALT, stop the pipeline and report which check failed. Include the full checks[] array in the checkpoint output.

Checkpoint output:

[HOOK 4] state=PROCEED|PROCEED_WITH_FLAGS|HALT
  max_risk: PASS|FAIL -- trade risk X.XX%
  max_positions: PASS|FAIL -- N open positions
  circuit_breaker: PASS|FAIL -- daily P&L $X.XX
  rr_gate: PASS|FAIL -- R:R X.XX:1
  sector_concentration: FLAG|n/a -- N positions in sector

Decision: PROCEED / PROCEED_WITH_FLAGS / HALT

---

Stage 4b: Adversarial Challenge

Isolated LLM inference with adversarial persona.

Load ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/adversarial-challenge.md. This prompt has ONE objective: kill the trade.

Feed the adversarial prompt the full pipeline state (signal, fundamentals, risk sizing, sentiment) and instruct it to construct the strongest possible case AGAINST the trade.

Required Analysis

1. Thesis inversion — what if the opposite is true?
2. Historical analogs — similar setups that failed
3. Crowded trade risk — is everyone seeing the same setup?
4. Correlation to existing positions — does this add concentration risk?
5. Macro headwinds — what didn't the hooks catch?

Output

adversarial_brief:
  attack_vectors:
    - {vector: "name", evidence: "specific evidence", severity: low|medium|high}
  strongest_bear_case: "paragraph summary"
  thesis_invalidation: "what would prove the trade wrong"
  survives_challenge: true | false
  severity: low | medium | high
  recommendation: PROCEED | PROCEED_WITH_FLAGS | HALT

---

Hook 5: Adversarial Gate

Outcome	Action
survives: true	Attach brief to proposal card — human sees bull AND bear case
survives: false, severity medium	PROCEED_WITH_FLAGS — strong warning shown
survives: false, severity high	HALT — adversarial case too strong

The adversarial brief is ALWAYS shown on the proposal card regardless of outcome.

Decision: PROCEED / PROCEED_WITH_FLAGS / HALT

---

Stage 5: Trade Proposal + Execution

Step 1: Format Proposal Card

Present the full proposal card to the human:

TRADE PROPOSAL: DIRECTION TICKER @ $PRICE
==========================================

Signal:   [primary signals]
          N/5 timeframes aligned | Conviction: HIGH|MEDIUM|LOW
News:     CONFIRMING|NEUTRAL|CONTRADICTING -- "[headline]"
Size:     Phase 1: N shares ($X) -- 50% of target
          Phase 2: +N shares if price moves 1R in favor
Risk:     $X (X.X% of $XX,XXX account)
Stop:     $X.XX (-X.X%, within 8% Minervini cap)
Target:   $X.XX (+X.X%)
R:R:      X.X:1

SIGNAL WEIGHTS (Darwinian):
  [source]: [weight] ([accuracy]%, [N]-trade window)
  ...
  Regime: [REGIME] (day N) -- [behavior mode]

REASONING TRAIL:
[status] Hook 1: [summary]                           [METRIC]
[status] Hook 2: [summary]                           [METRIC]
         Conflict assessment: [summary]               [LLM]
[status] Hook 3: [summary]                           [METRIC]
         Filing memo: [summary]                       [LLM]
[status] Hook 4: [summary]                           [METRIC]
[status] Hook 5: ADVERSARIAL CHALLENGE                [LLM]
         "[strongest bear case summary]"
         Attack severity: [severity] | Survives: [yes/no]

APPROVE? [yes / no / adjust size / skip]

Step 2: Wait for Human Approval

Do NOT proceed without explicit human approval. Accept:

• yes — proceed to preflight + execution
• no — cancel, log as rejected trade
• adjust size — modify position size, re-run Hook 4, re-present
• skip — move to next candidate

Step 3: Execution Preflight

After human says yes, gather live data then run the validation script. If ANY check fails, abort and explain.

1. Gather live data:

   • Re-fetch live quote: mcp__alpaca__get_stock_latest_quote
   • Re-fetch positions: mcp__alpaca__get_all_positions
   • Re-fetch account: mcp__alpaca__get_account_info
   • Check market: mcp__alpaca__get_clock
   • Compute approval_age_seconds from when human said "yes"

2. Run preflight validation script:

   node ${CLAUDE_PLUGIN_ROOT}/skills/shared/validate.mjs '{"command":"preflight","direction":"LONG|SHORT","live_price":PRICE,"stop_price":STOP,"target_price":TARGET,"position_size":SIZE,"account_equity":EQUITY,"buying_power":BP,"exposure_ceiling":CEILING,"existing_notional":EXISTING,"open_positions":COUNT,"daily_pnl":PNL,"market_open":true|false,"asset_class":"equity|crypto","approval_age_seconds":SECONDS}'
   

3. Handle result:

   • If state is HALT: abort execution, report which check(s) failed
   • If suggested_adjustment is present (risk too high at live price): present adjusted quantity for re-approval
   • If state is PROCEED or PROCEED_WITH_FLAGS: proceed to execution

Checkpoint output:

[PREFLIGHT] state=PROCEED|PROCEED_WITH_FLAGS|HALT
  ttl: PASS|FAIL -- approval Ns old
  live_risk: PASS|FAIL -- X.XX% at $live_price
  live_rr: PASS|FAIL -- X.XX:1 at live price
  buying_power: PASS|FAIL -- notional $X vs $BP
  exposure: PASS|FAIL -- X.X% vs ceiling
  positions: PASS|FAIL -- N open
  circuit_breaker: PASS|FAIL -- daily P&L $X
  market_status: PASS|FAIL -- open|closed

Step 4: Execute

Place the order via mcp__alpaca__place_stock_order (equities) or mcp__alpaca__place_crypto_order (crypto).

Use bracket orders when available:

order_class: "bracket"
side: "buy" | "sell"
type: "limit"
limit_price: entry_price
qty: position_size (Phase 1 -- 50% of target)
time_in_force: "day"
take_profit: {limit_price: target_price}
stop_loss: {stop_price: stop_loss_price}

Step 5: Log to Journal

Write entry to ~/trading-journal/YYYY-MM-DD.md (create if doesn't exist):

## Trade #N -- TICKER DIRECTION [OPEN]
- Entry: $XX.XX (Phase 1: N shares @ HH:MM ET)
- Phase 2: pending -- +N shares if price > $XX.XX (1R in favor)
- Stop: $XX.XX | Target: $XX.XX
- Risk: $XXX (X.X%) | R:R: X.X:1
- Hooks: [pass/warn/fail] summary
- Signal: [description]
- News: [alignment] -- [headline]
- Adversarial: [severity] -- "[strongest bear case]"
- Darwinian weights at time of trade: {source: weight, ...}
- Regime: [regime] (day N)

Step 6: Save Pipeline State Snapshot

Write JSON snapshot to ~/trading-journal/snapshots/YYYY-MM-DD-TICKER-N.json:

{
  "trade_id": "YYYY-MM-DD-TICKER-N",
  "timestamp": "ISO-8601",
  "ticker": "TICKER",
  "direction": "LONG|SHORT",
  "regime": "BULL|CORRECTION|BEAR|CRISIS|RECOVERY",
  "morning_context": { },
  "market_context": { },
  "signal": { },
  "conflict_assessment": { },
  "fundamental_memo": { },
  "risk_assessment": { },
  "adversarial_brief": { },
  "darwinian_weights": { },
  "hook_results": {
    "hook1": "PROCEED|PROCEED_WITH_FLAGS|...",
    "hook2": "...",
    "hook3": "...",
    "hook4": "...",
    "hook5": "..."
  },
  "proposal_card": "full text",
  "human_decision": "yes|no|skip",
  "execution": {
    "order_id": "alpaca-order-id",
    "fill_price": null,
    "status": "submitted"
  }
}

These snapshots enable autoresearch replay and Darwinian scoring.

Retention policy: Keep all snapshots during Phase 3-4 (first ~6 months). Review and archive after 6 months — autoresearch regression checks only need the most recent 30 per source.

---

Darwinian Signal Weighting

Scorecard File

~/trading-journal/scorecards.json:

{
  "sources": {
    "tradingview_combined_analysis": {
      "trades": [],
      "rolling_window": 30,
      "correct_calls": 0,
      "total_scored": 0,
      "accuracy": 0.5,
      "weight": 1.0
    },
    "tradingview_multi_timeframe": { },
    "tradingview_volume": { },
    "tradingview_sentiment": { },
    "edgartools_fundamentals": { }
  },
  "regime_scorecard": {
    "BULL": {"trades": 0, "wins": 0, "accuracy": 0.0, "avg_R": 0.0},
    "CORRECTION": {"trades": 0, "wins": 0, "accuracy": 0.0, "avg_R": 0.0},
    "BEAR": {"trades": 0, "wins": 0, "accuracy": 0.0, "avg_R": 0.0},
    "CRISIS": {"trades": 0, "wins": 0, "accuracy": 0.0, "avg_R": 0.0},
    "RECOVERY": {"trades": 0, "wins": 0, "accuracy": 0.0, "avg_R": 0.0}
  }
}

Weight Formula

weight = 0.3 + (2.0 - 0.3) x (accuracy - 0.3) / 0.7

• Floor: 0.3 (worst source still contributes)
• Ceiling: 2.0 (best source capped)
• 30% accuracy -> 0.3 weight, 100% accuracy -> 2.0 weight

Bootstrap Period

For the first 30 trades, all sources use equal weight (1.0). Darwinian weighting activates once every active source has at least 10 scored trades.

Scoring Trades

After a trade closes (manually tracked), update scorecards:

• Each source scored on whether its signal direction matched the trade outcome
• Direct-match: source recommended LONG, trade was profitable -> correct
• Update rolling 30-trade window, recalculate accuracy and weight

---

Autoresearch: Prompt Evolution (Phase 3+)

Autoresearch activates after trade 40. It is a weekly mutation cycle that evolves the prompt files in ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/ based on trading performance. Full specification is in the design doc (~/Documents/docs/plans/2026-04-01-trading-orchestrator-design.md, section "Autoresearch: Prompt Evolution Loop").

Summary

1. RANK: Identify the weakest prompt by Sharpe contribution across the rolling window
2. MUTATE: Generate a targeted mutation hypothesis and modify the weakest prompt on a git branch
3. SHADOW RUN: A/B test the mutation over 10 trading days (minimum 5 trades) using single-component replay against pipeline state snapshots
4. EVALUATE: Three-gate evaluation:
   • Gate 1: Composite score delta > 0.05 (improvement threshold)
   • Gate 2: Paired sign test p < 0.20 (statistical significance)
   • Gate 3: Regression check on 30 historical trades (no degradation)
5. KEEP or REVERT: If all 3 gates pass -> merge prompt branch. If any fail -> revert. Human approves keep/revert decisions.

Guardrails

• Continuous drift monitoring: drift_score = lines_changed + 0.1 x mutations_kept. If > 0.5, flag for human review.
• Human review required every 3rd kept mutation
• Quarterly anchor evaluation: re-run current prompts against v0 baselines (stored in ~/trading-journal/prompt-baselines/)
• All mutations logged in ${CLAUDE_PLUGIN_ROOT}/skills/shared/prompts/CHANGELOG.md and ~/trading-journal/autoresearch-log.json

Not Active Until

• 40+ closed trades (sufficient data for Sharpe contribution)
• Every active source has 10+ scored trades (Darwinian weighting active)
• Semi-automated via /schedule — human triggers and approves each cycle

---

LLM Inference Boundaries (Non-Negotiable)

LLM CAN:

• Synthesize unstructured evidence (news, filings, social text)
• Classify contradictions between signals
• Generate rationale and explanations
• Assess severity of events
• Extract red flags from SEC filings
• Tighten constraints via the ratchet (NEVER loosen)

LLM MUST NOT:

• Override hard risk gates (1% max, 5% circuit breaker, position limits)
• Modify position sizing math
• Loosen market-state constraints (exposure ceilings)
• Bypass the human approval gate
• Invent data (report gaps, don't estimate)
• Auto-approve trades regardless of conviction

---

Rejected Trades

When the pipeline halts at any hook, log to the daily journal:

## Rejected Trade #N -- TICKER DIRECTION
- Rejected at: Hook N (reason)
- Action: No trade placed

---

Daily Summary

At end of session or on request, append to the daily journal:

## Daily Summary
- Trades executed: N | Rejected: N
- Open risk: $XXX (X.X% of account)
- Daily P&L: +/-$XXX
- Consecutive W/L: NW / NL
- Account equity: $XX,XXX

---

Error Handling

• MCP tool returns error or empty -> log the gap, note it in the relevant stage output, continue if possible
• Multiple tools fail in same stage -> surface as PROCEED_WITH_FLAGS with "degraded data quality" flag
• All market data fails -> NO_NEW_EXPOSURE (cannot assess risk without data)
• Alpaca connection fails -> HALT (cannot execute, verify, or monitor)
• Journal write fails -> warn user, do not block the trade pipeline