Trader India

---
name: trader-india
description: >-
  Day Trader for NSE (India). The Day Trader skill pack's one-trade pipeline (scanner -> entry ->
  exit plan -> time machine -> budget -> risk) rebuilt for the National Stock Exchange: Nifty 100
  stocks, IST, rupees, 09:15-15:30 session, flat by 15:15 (Zerodha MIS square-off), Zerodha
  intraday charges, NSE 0.05 tick. Its rule was tuned on NSE 1-minute data from Feb 2015 to Dec
  2017 only and frozen, then scored once on 2018 to Apr 2026, where it FAILED (lost money after
  costs). Writes paper tickets in Kite's order shape; it never places an order. Use when the user
  says "scan NSE", "Indian day trade", "opening range breakout on Nifty stocks", "intraday setup
  for RELIANCE", "size my MIS trade", "how did the India rule do", or names an NSE symbol with a
  day-trading request.
argument-hint: "[rule | scan | check SYMBOL | replay SYMBOL | size | risk]"
---

# trader-india

The Day Trader skill (github.com/Jakeschincariol/day-trader-skill, MIT) for Indian markets. The
eleven US skills are installed alongside it; this one does the same day trade on NSE with one
frozen rule. Before anything else, tell the user plainly: **this rule failed its blind test.** It is
for study and paper trading. Most people who day trade lose money; in India SEBI's study of FY2023
found about 7 in 10 intraday cash traders lost money.

`${CLAUDE_SKILL_DIR}` below is this skill's folder.

```bash
python "${CLAUDE_SKILL_DIR}/nse.py" rule                      # the frozen rule and how it did
python "${CLAUDE_SKILL_DIR}/nse.py" scan                      # after 09:30 IST: every universe stock vs the rule -> trader/scan_in.json
python "${CLAUDE_SKILL_DIR}/nse.py" scan --symbols SBIN,TCS   # a few names (faster)
python "${CLAUDE_SKILL_DIR}/nse.py" check RELIANCE            # waiting / triggered / expired, with the plan
python "${CLAUDE_SKILL_DIR}/nse.py" replay RELIANCE           # time machine: the rule on its last ~60 sessions
python "${CLAUDE_SKILL_DIR}/nse.py" size --capital 500000     # paper tickets -> trader/orders_in.json
python "${CLAUDE_SKILL_DIR}/nse.py" risk                      # PASS / BLOCK each ticket
```
`--now "2026-10-27 10:15"` (IST) pins the clock, `--json` prints raw JSON.

## The frozen rule (frozen.json)

- **Setup:** the 15-minute opening range (09:15-09:30). **Short** the first completed 5-minute
  bar that CLOSES below the range low. No volume check, no daily filter, no time-machine gate.
- **Exit plan:** stop at the opening-range high (rounded to the 0.05 tick away from the entry),
  target 2R, flat by 15:15 IST either way.
- **Budget and risk:** 1% of capital max loss a trade, 1 trade a day, max position 75% of capital,
  10% cash buffer, total risk 3% a day, no leverage.

Short selling intraday is allowed for NSE cash stocks under MIS, and the position must be squared
off the same day. The original skill is long-only; here the side came out of training: on
2015-17 every long variant lost money after charges, and only short setups made money.

## How it was chosen, and how it did

Data: 1-minute OHLCV for today's Nifty 100 stocks (Kaggle, debashis74017, CC0), Feb 2015 to
Apr 2026. It was checked against NSE's own daily highs and lows: 97.7% of stock-days agree. 25,920
rule variants were scored on 2015-17 only, with realistic fills at Rs 5 lakh: enter at the next
minute's open, 0.04% slippage a side, stops that gap fill at the open, Zerodha charges, and 31.2%
tax on a year's profit. Then the frozen rule ran once on 2018 to Apr 2026 (`nse.py rule --json`
prints every year).

| period (realistic fills, Rs 5 lakh) | after tax and charges | Sharpe | worst drawdown |
| --- | --- | --- | --- |
| 2015 / 2016 / 2017 (training) | +8.7% / +6.8% / +4.9% | 1.04 / 0.86 / 0.67 | -12.8% / -14.0% / -4.7% |
| 2018 to Apr 2026 (blind) | **-33.7% in total** | -0.37 | -53.1% |
| Nifty 50, 2018-2025 | positive every year | | |

The average signal still makes about 1-8 basis points a trade before costs in the test years, but
a round trip costs about 12 (STT, charges, slippage). The skill's own defaults (long breakouts,
range-midpoint stop, 2R, 3 trades a day) lost about 98% over the same test. Caveats: the stock list
is today's Nifty 100 (survivorship bias), today's charge schedule is applied to every year, and
the live tool reads 5-minute Yahoo bars while the backtest exits used 1-minute bars.

Research code: `signal1/backend/mir/research/daytrader_in.py`; data and results under
`E:\projects\signal\research\intraday_nse`.

## Steps

1. Say that the rule failed its blind test and that this is paper only. Run `nse.py rule` if
   the user asks how it was made.
2. After 09:30 IST run `scan` (or `check SYMBOL`). Report the hits in trigger order with entry,
   stop, target and risk %. A scan is a list of charts that match a rule, not stocks to sell.
3. `replay SYMBOL` before a trade: how the rule did on this stock over the last ~60 sessions.
4. `size --capital N` then `risk`. Read back each ticket (quantity, stop, target, max loss at
   the stop, estimated charges) and its PASS / BLOCK.
5. Never place an order. If the user wants to trade it anyway, they place it themselves in Kite.
   Say once that a stop is a plan, not a guarantee: a gap fills past it.

## What it never does

It never places, modifies or cancels an order, never touches a broker API or keys, never turns on
live trading (the AutoTrader's Zerodha connection stays disabled), never re-tunes the frozen rule
on 2018+ data, and never calls a backtest a promise. Not investment advice.