Startup India eligibility skill for Claude

---
name: startup-india-eligibility
description: Checks whether an Indian startup qualifies for DPIIT startup recognition under Startup India and for the benefits that depend on it, namely the Section 80-IAC tax holiday (now Section 140 of the Income-tax Act, 2025), ESOP tax deferral, the Seed Fund Scheme, the Credit Guarantee Scheme and Fund of Funds-backed investment. Works from the entity type, incorporation date, turnover in each financial year, whether it was split from an existing business and what it does. A script tests the age and turnover limits, the 80-IAC incorporation window and the years a tax holiday could cover. Returns an eligibility table, key dates, documents to prepare and official portal links, and covers the angel tax (Section 56) position and what changes with foreign investment. Use when a founder asks about DPIIT recognition, Startup India registration, being a recognised startup, 80-IAC or the startup tax holiday, the IMB certificate, angel tax, ESOP tax, the seed fund scheme, CGSS or other startup benefits in India.
license: MIT
compatibility: Works on claude.ai, Claude Code and the Claude API. The script needs Python 3.8+ (standard library only) and no network access.
metadata:
  author: StartupReader
  version: "1.0"
  homepage: https://startupreader.com/claude-skills/startup-india-eligibility
---

# Startup India eligibility

Turn a company's facts into an eligibility table for DPIIT recognition and the benefits that depend on it, with the dates that matter, the documents to prepare and the official portals. The rules come from [references/rules.md](references/rules.md), last checked on 8 November 2026. Indian rules change in Budgets, so confirm current thresholds on the official portal before relying on them. The answer is a checklist, not tax or legal advice. Say so once, at the end.

## Workflow

Copy this checklist and tick it off as you go:

```
- [ ] 1. Collect the facts
- [ ] 2. Run scripts/eligibility.py
- [ ] 3. Read references/rules.md for what the script does not test
- [ ] 4. Confirm current thresholds on the official portals
- [ ] 5. Write the answer in the output format below
- [ ] 6. Run the self-check
```

### 1. Collect the facts

The entity type and the incorporation date are required. Ask for the rest; if the founder does not know a fact, leave it out and the script marks that test "Needs checking". Never fill a gap with a guess.

| Fact | JSON key | Flag |
|---|---|---|
| Entity type: private-limited, llp, registered-partnership, cooperative-society, one-person-company, public-limited, unregistered-partnership, sole-proprietorship | `entity_type` | `--entity` |
| Incorporation date (certificate of incorporation) | `incorporated` | `--incorporated` |
| Turnover in every financial year since incorporation, April to March | `turnover` | `--turnover FY=AMOUNT` |
| Formed by splitting up or reconstructing an existing business? | `split_or_reconstructed` | `--split` |
| Plant or machinery used before transferred in? | `reused_plant_or_machinery` | `--used-plant` |
| Works on innovation, improvement or a scalable model? | `innovation` | `--innovation` |
| DeepTech? | `deep_tech` | `--deep-tech` |
| Already DPIIT-recognised? Holds the IMB certificate for 80-IAC? | `dpiit_recognised`, `imb_certificate` | `--recognised`, `--imb-certificate` |
| Indian promoters' shareholding, % | `indian_promoters_pct` | `--indian-promoters` |
| Money from other central or state government schemes | `other_government_support` | `--govt-support` |
| Any foreign investors? In default or an NPA? | `foreign_investors`, `in_default` | `--foreign-investors`, `--in-default` |
| Profit of the eligible business by year, actual or projected | `profit` | `--profit FY=AMOUNT` |
| Date to check on (default today) | `as_of` | `--as-of` |

Yes/no facts take yes, no or unknown. Amounts are rupees: `12500000`, `"1.25 crore"` or `"12.5 lakh"`. Ask what the business does in a sentence or two: DPIIT and the IMB judge innovation, so record the founder's answer and treat the test as theirs to confirm. If the founders hold shares through a company abroad, run the checks on the Indian company.

### 2. Run the script

Write the facts to a JSON file shaped like [assets/example-company.json](assets/example-company.json), then run the script instead of working out dates and limits yourself:

```bash
# All checks for the fictional example company
python scripts/eligibility.py assets/example-company.json

# The founder's facts
python scripts/eligibility.py facts.json

# No file: facts as arguments
python scripts/eligibility.py --entity llp --incorporated 2024-06-03 --turnover 2024-25="18 lakh" --turnover 2025-26="1.2 crore" --innovation yes

# What-if: arguments override the file; --only prints one section (dpiit, 80iac, seed-fund, cgss, dates)
python scripts/eligibility.py facts.json --only 80iac --turnover 2029-30=1040000000
```

- Every line is Eligible, Not eligible or Needs checking. "(as stated)" means the line repeats the founder's answer.
- The 80-IAC section lists the ten-year window and each three-year block still open, with the profit it would cover from the figures given. Projected turnover over ₹100 crore drops that year from a block. Blocks that began in past years are summarised in one line for a chartered accountant (CA) to look at.
- If the script exits with `Error: ...`, fix the input it names and run it again. Do not estimate instead.

### 3. Rules the script does not test

Read [references/rules.md](references/rules.md) before writing. It covers angel tax, the ESOP deferral, Fund of Funds, foreign investment, Udyam registration, the documents for each application and the official portals. Keep these straight:

- **Recognition is not the tax holiday.** 80-IAC needs a separate certificate from the Inter-Ministerial Board (IMB), with stricter tests: company or LLP only, incorporated from 1 April 2016 and before 1 April 2030, turnover under ₹100 crore, no DeepTech extension.
- **ESOP deferral follows the IMB certificate**, not recognition alone. Do not state the deferral period for shares allotted from 1 April 2026; rules.md explains why.
- **Name the section once:** "Section 80-IAC (now Section 140 of the Income-tax Act, 2025)", then 80-IAC.
- **Angel tax** stopped applying from 1 April 2025, but valuations are still needed for foreign investors and preferential allotments. For shares issued during 2024-25, send the founder to a tax adviser.
- **Never round or merge limits.** Recognition is "below ₹200 crore in every financial year"; 80-IAC is "under ₹100 crore". Keep "in every financial year".
- **Recognition is free** and DPIIT appoints no agents. Never suggest paying one.

### 4. Confirm current thresholds

rules.md was last checked on 8 November 2026. Union Budgets (usually in February) and notifications change these rules.

- If you can browse, open the official page listed in rules.md for each benefit in your answer and compare the figures. If one differs, use the official figure and say what changed.
- If you cannot browse, say that the figures were last checked on 8 November 2026 and should be confirmed on the portal.
- If today is after a Union Budget later than 8 November 2026, say that the Budget may have changed these rules.

### 5. Output format

```markdown
# Startup India eligibility: [Company]
Checked on [date], using rules last verified on 8 November 2026.

## Eligibility
| Benefit | Status | Rule | Fact it depends on |
|---|---|---|---|
| DPIIT recognition | ... | ... | ... |
| Section 80-IAC tax holiday | ... | ... | ... |
| ESOP tax deferral | ... | ... | ... |
| Angel tax | ... | ... | ... |
| Seed Fund Scheme | ... | ... | ... |
| Credit Guarantee Scheme | ... | ... | ... |
| Fund of Funds (through AIFs) | ... | ... | ... |
| Foreign investment | ... | ... | ... |  (only if there are or will be foreign investors)
Then one sentence for each "Needs checking" row on what would settle it.

## Dates that matter
Earliest first: deadlines already passed (marked), the three-year tax holiday blocks still open with the profit each covers, the end of the 80-IAC window, the end of recognition, and any year in which projected turnover crosses a limit.

## Documents to prepare
Grouped by benefit, only for benefits that are Eligible or Needs checking.

## Official portals
The links from references/rules.md for the benefits above.

This is a checklist to discuss with your chartered accountant or lawyer, not tax or legal advice. The rules were last checked on 8 November 2026; confirm current thresholds on the official portals.
```

Use the three statuses exactly for benefits. The angel tax and foreign investment rows are not benefits: say what applies instead. Write rupees as ₹ with lakh and crore, and financial years as FY 2025-26.

### 6. Self-check

- Every date, amount and percentage comes from the script output, the founder's facts or references/rules.md.
- Each row gives the rule and the fact it turns on.
- Recognition and the tax holiday are separate rows, and the ESOP row depends on the IMB certificate.
- Holiday blocks say "could cover", never "will save". You show the blocks; a CA confirms the choice, because real tax depends on more than profit.
- Step 4 was done, and the answer says how.
- The answer ends with the disclaimer above.

{
  "note": "Fictional company for illustration. Amounts in rupees; FY 2026-27 onwards are projections.",
  "name": "Monsoon Ledger Labs Pvt Ltd",
  "entity_type": "private-limited",
  "incorporated": "2021-08-12",
  "as_of": "2026-11-08",
  "deep_tech": false,
  "split_or_reconstructed": false,
  "reused_plant_or_machinery": false,
  "innovation": true,
  "dpiit_recognised": true,
  "imb_certificate": false,
  "indian_promoters_pct": 82,
  "other_government_support": 500000,
  "foreign_investors": true,
  "in_default": false,
  "turnover": {
    "2021-22": 640000,
    "2022-23": 11000000,
    "2023-24": 32000000,
    "2024-25": 68000000,
    "2025-26": 115000000
  },
  "profit": {
    "2021-22": -4200000,
    "2022-23": -9500000,
    "2023-24": -6000000,
    "2024-25": -1500000,
    "2025-26": 2800000,
    "2026-27": 9000000,
    "2027-28": 18000000,
    "2028-29": 30000000,
    "2029-30": 42000000,
    "2030-31": 50000000
  }
}

# Startup India eligibility rules

Last checked: 8 November 2026 (2026-11-08), against the official pages and StartupReader pages listed in section 12. Indian rules change in Union Budgets and by notification: confirm every threshold on the official portal before relying on it.

## Contents
1. DPIIT recognition
2. Section 80-IAC tax holiday (Section 140 of the Income-tax Act, 2025)
3. ESOP tax deferral
4. Angel tax
5. Startup India Seed Fund Scheme
6. Credit Guarantee Scheme for Startups (CGSS)
7. Fund of Funds for Startups (FFS)
8. What changes with foreign investment
9. Udyam (MSME) registration
10. Documents to prepare
11. Official portals
12. Sources, wording differences and what is left out

## 1. DPIIT recognition

Issued by the Department for Promotion of Industry and Internal Trade under Startup India. An entity must meet every test:

| Test | Rule |
|---|---|
| Entity type | Private limited company, registered partnership firm, limited liability partnership (LLP) or cooperative society. Sole proprietorships, unregistered partnerships and public limited companies are not on the list. A one person company is not named: confirm on NSWS. |
| Age | Up to 10 years from the date of incorporation (20 years for DeepTech startups). |
| Turnover | Below ₹200 crore (₹300 crore for DeepTech) in every financial year since incorporation. |
| Innovation | Works towards innovation or improvement of products, services or processes, with potential to generate employment or create wealth. DPIIT judges this. |
| Original entity | Not formed by splitting up or reconstructing an existing business. |

- DeepTech status is DPIIT's decision. A company that passes only on the DeepTech limits is "needs checking".
- An entity stops counting as a startup once the age limit is reached, or once its turnover in a financial year goes over the limit (for exactly ₹200 crore, see section 12).
- Apply free on the National Single Window System (nsws.gov.in): Add Approvals > Central Approvals > "Registration as a Startup". File with the company's own email and mobile number. DPIIT charges no fee and appoints no agents.
- Certificates can be verified or downloaded on the Startup India portal or DigiLocker.
- What recognition unlocks (StartupReader DPIIT guide): self-certification under 6 labour laws and 3 environmental laws for 5 years; fast-tracked patent applications with an 80% rebate on filing fees and government-paid facilitators; winding up within 90 days under the Insolvency and Bankruptcy Code, 2016 for simple debt structures; exemption from prior experience, turnover and earnest money deposit criteria in public procurement, and listing on GeM. It is also the entry ticket for 80-IAC, the Seed Fund Scheme, CGSS, funding from FFS-backed funds and convertible notes from foreign investors.

## 2. Section 80-IAC tax holiday (Section 140 of the Income-tax Act, 2025)

The Income-tax Act, 2025 replaced the 1961 Act from 1 April 2026. The startup deduction that was Section 80-IAC is now Section 140 ("Special provision in respect of specified business"). Startup India's pages still call it 80-IAC.

What it gives: a deduction of 100% of the profits and gains derived from the eligible business, for any three consecutive tax years out of ten years beginning from the year in which the start-up is incorporated (Section 140(1) and (2)).

Counting the ten years: the financial year of incorporation is year 1, so year 10 is nine financial years later. Incorporated on 12 August 2021: FY 2021-22 to FY 2030-31, and a three-year block can start in any of years 1 to 8. The deduction is worth nothing in a loss year, so the choice of block matters.

| Test | Rule | Source |
|---|---|---|
| Recognition | DPIIT-recognised first | Startup India 80-IAC page |
| Certificate | Holds a certificate of eligible business from the Inter-Ministerial Board of Certification (IMB) | Section 140(16)(b)(iii) |
| Entity type | Private limited company or LLP (the Act says "a company or a limited liability partnership"). Partnership firms and cooperative societies cannot claim it. | Startup India; Section 140(16)(b) |
| Incorporation | On or after 1 April 2016 and before 1 April 2030 | Section 140(16)(b)(i); IMB page |
| Age | Less than 10 years old when applying | Startup India 80-IAC page |
| Turnover | Less than ₹100 crore in any financial year (Startup India). The Act: total turnover does not exceed ₹100 crore in the year for which the deduction is claimed. | Startup India; Section 140(16)(b)(ii) |
| Business | Innovation, development or improvement of products, processes or services, or a scalable business model with high potential for employment generation or wealth creation | Section 140(16)(a) |
| Formation | Not formed by splitting up or reconstructing an existing business, nor by transferring previously used plant or machinery to a new business. Used plant up to 20% of the total value is allowed; machinery used only outside India, imported and never depreciated in India does not count as used. A business re-established after a natural calamity, riot, fire or enemy action can qualify. | Section 140(3) to (6) |
| Audit | Accounts of the eligible business audited for each year claimed, with the audit report furnished by the specified date | Section 140(8) |

- No DeepTech extension: neither the Act nor Startup India's 80-IAC criteria give DeepTech startups longer age or turnover limits.
- Turnover in practice: a year over ₹100 crore cannot be claimed, and a past year over it fails the Startup India application test. Exactly ₹100 crore is "needs checking" because the sources word the test differently.
- Scalability declaration (Startup India format): more than 10% revenue growth from one financial year to the next, or more than 25% cumulative growth over two financial years, or more than 33% over three. The script uses turnover as revenue.
- How the IMB evaluates: innovation grading (intellectual property, awards, product stage), scalability (the growth tests), wealth generation (funding, revenue, profitability) and employment (direct employment, diversity, staff in non-metro cities).
- Process: after recognition, log in to the Startup India portal with the same credentials, confirm the recognition details, fill in the 80-IAC details, upload documents, complete the scorecard, self-certify and submit. Track the status on the dashboard. StartupReader has no figure for how long the IMB takes.

## 3. ESOP tax deferral

- Normal rule: when an employee exercises options, the gap between the fair market value (FMV) on the exercise date and the price paid is taxed as salary (a perquisite), and the employer deducts the tax. On sale, the gain above that FMV is a capital gain, with the holding period counted from allotment. For unlisted shares, FMV is set by a merchant banker on the exercise date or a date up to 180 days earlier.
- Who can defer: only employees of an "eligible start-up as referred to in Section 80-IAC" (incometaxindia.gov.in), which means a start-up that meets the 80-IAC conditions, including the IMB certificate. DPIIT recognition alone is not enough. StartupReader's pages say "eligible DPIIT-recognised startups"; this is what "eligible" means.
- When the tax falls due under the 1961 Act text on incometaxindia.gov.in: the employer deducts it within 14 days of the earliest of (a) 48 months from the end of the assessment year in which the shares were allotted, (b) the employee leaving, (c) the employee selling the shares, at the rates for the year of allotment.
- From 1 April 2026: Section 392(3) of the Income-tax Act, 2025 keeps the deferral for "an eligible start-up referred to in section 140", with the tax deducted within the time specified in Section 289(3). Section 289(3) could not be read on the official site, so confirm the period for shares allotted from 1 April 2026 before stating it.
- The deferral moves the tax; it does not cancel it.

## 4. Angel tax

- "Angel tax" was Section 56(2)(viib) of the Income-tax Act, 1961: an unlisted company was taxed on share premium received above the fair market value of the shares.
- The July 2024 Budget announced its abolition for all classes of investors. The Finance (No. 2) Act, 2024 says the clause "shall not apply on or after the 1st day of April, 2025".
- Advisers read the cut-off differently for shares issued during 2024-25: if a round fell then, ask a tax adviser. The change was not retrospective, so earlier years can still be assessed under the old rule. Commentators note the Income-tax Act, 2025 has no equivalent provision.
- The old DPIIT exemption (February 2019 notification, Form 2) capped paid-up capital plus share premium after the issue at ₹25 crore, leaving out money from non-residents and venture capital funds. It matters only for old rounds.
- Still needed: a FEMA fair-value certificate for foreign investors, a registered valuer's report for preferential allotments, evidence of where money came from, and care with secondary sales below fair market value.

## 5. Startup India Seed Fund Scheme

StartupReader has no published guide to this scheme; these rules are from the scheme's own site (seedfund.startupindia.gov.in/about).

| Test | Rule |
|---|---|
| Recognition and age | DPIIT-recognised, and incorporated not more than 2 years before applying |
| Business | A product or service idea with market fit, viable commercialisation and scope of scaling, using technology in its core product, service, business model, distribution model or method |
| Other government money | Not more than ₹10 lakh of monetary support under any other central or state government scheme. Prize money, subsidised working space, founder monthly allowance and access to labs or prototyping facilities do not count. |
| Ownership | Indian promoters hold at least 51% when applying to the incubator |

- Money: up to ₹20 lakh as a grant for proof of concept, prototype development or product trials, paid in milestone instalments; up to ₹50 lakh for market entry, commercialisation or scaling through convertible debentures, debt or debt-linked instruments. Each form once.
- It is paid through incubators selected under the scheme, not by the government directly.

## 6. Credit Guarantee Scheme for Startups (CGSS)

- Borrower: DPIIT-recognised; not in default to any lending or investing institution and not a non-performing asset (NPA); eligibility certified by the lender (the member institution); a stable revenue stream, assessed from audited monthly statements over 12 months.
- Lenders: scheduled commercial banks and financial institutions; RBI-registered NBFCs rated BBB or above with a net worth of at least ₹100 crore; SEBI-registered Alternative Investment Funds. They register on the NCGTC portal.
- Loans covered: venture debt, working capital, subordinated debt, debentures, optionally convertible debt and other facilities that become debt obligations.
- Cover: at most ₹20 crore per borrower. Transaction-based cover is 85% of the amount in default for loans up to ₹10 crore and 75% above that. Umbrella-based cover for venture debt funds covers actual losses or 5% of the pooled investment, whichever is lower.
- Applying: through the Jan Samarth portal or a member institution's branch. The startup does not apply to the guarantor directly; the lender applies for the cover after sanctioning the loan.

## 7. Fund of Funds for Startups (FFS)

- A ₹10,000 crore fund launched in June 2016, managed by SIDBI for DPIIT. It invests in SEBI-registered Category I and II AIFs, which invest in startups.
- Founders cannot apply to FFS. They approach AIFs that have FFS commitments; the AIF makes its own decision. Funding from FFS-backed AIFs needs DPIIT recognition.
- StartupReader's FFS guide quotes an older DPIIT definition (₹100 crore turnover, no cooperative societies). Use section 1 for the current definition.

## 8. What changes with foreign investment

- Recognition and 80-IAC: the official criteria have no foreign-ownership condition. They apply to the Indian entity; a holding company abroad is not one of the listed entity types, so run the checks on the Indian company.
- Seed Fund Scheme: Indian promoters must hold at least 51% when applying, so a cap table with heavy foreign ownership can fail.
- Pricing: shares issued to a non-resident cannot be priced below fair value certified by a chartered accountant, a SEBI-registered merchant banker or a practising cost accountant. For convertible instruments the conversion formula is fixed at issue and the conversion price cannot be below the fair value at that time.
- Filings: issue the shares within 60 days of receiving the money (or refund within 15 days after that); Form FC-GPR on the RBI's FIRMS portal within 30 days of issue; Form FC-TRS for transfers between residents and non-residents; the annual FLA return by 15 July; Form DI within 30 days for downstream investment by a foreign-owned company.
- Routes: most sectors allow investment without prior approval (automatic route). Some sectors, and investors whose beneficial owners are in a country sharing a land border with India (Press Note 3 of 2020, clarified in March 2026 for non-controlling beneficial ownership up to 10%), need government approval.
- Instruments: equity shares, CCPS, CCDs and warrants. Convertible notes only from DPIIT-recognised startups: at least ₹25 lakh from an investor in a single tranche, converted or repaid within ten years, reported on Form CN within 30 days. US-style SAFEs are not listed under the FEMA rules.
- Angel tax no longer applies to new issues, but the FEMA valuation does.
- ESOPs granted by a US parent fall under US 409A rules; the Indian deferral in section 3 is for employees of an eligible Indian start-up.

## 9. Udyam (MSME) registration

- A separate registration under the MSMED Act, not the same as DPIIT recognition, and needed for MSME benefits. Registration on the official portal (udyamregistration.gov.in) is free, per StartupReader's Udyam guide.
- Classification since April 2025 (investment in plant and machinery or equipment, and turnover; exports excluded): micro up to ₹2.5 crore and ₹10 crore, small up to ₹25 crore and ₹100 crore, medium up to ₹125 crore and ₹500 crore.

## 10. Documents to prepare

- DPIIT recognition: the certificate of incorporation or registration, and a description of what the business does and how it innovates or scales. The exact list is on NSWS; StartupReader's guide does not reproduce it.
- 80-IAC (Startup India 80-IAC page): shareholding pattern as per the Memorandum of Association and the latest structure; board resolution, if any; income-tax return acknowledgements and audited financial statements (balance sheet and profit and loss) for the past three years or since incorporation, certified by a chartered accountant; a CA certificate that the startup was not formed by splitting up or reconstruction and that no previously used plant or machinery was transferred; the declaration of scalability; proof of credit rating, if any; proof of IP filings and awards; a pitch deck (PDF, up to 5 MB); an HR declaration (staff with an M.Tech or PhD, total direct employment, women, persons with disabilities, SC/ST staff, staff in non-metro cities); proof of investment received (term sheets, investment agreements, bank statements, investor certificates, GST filings).
  - Audited statements by age: 1 to 2 years old, the first year; 2 to 3 years, the last two; over 3 years, the latest three.
- Seed Fund Scheme: the DPIIT certificate, a CA certificate that the startup has not received more than ₹10 lakh under other government schemes, and the shareholding showing Indian promoters' share.
- CGSS: the DPIIT certificate and audited monthly statements covering 12 months, plus the lender's own list.
- ESOP deferral: the IMB certificate, a merchant banker valuation for each exercise, and a record of allotment dates.
- Foreign round: a fair-value certificate dated close to the issue, board and shareholder approvals, and Form FC-GPR.

## 11. Official portals

- DPIIT recognition (apply): https://www.nsws.gov.in
- Startup India recognition and tax exemption: https://www.startupindia.gov.in/content/sih/en/startupgov/startup_recognition_page.html
- 80-IAC application: https://www.startupindia.gov.in/content/sih/en/form80iac.html
- Inter-Ministerial Board: https://www.startupindia.gov.in/content/sih/en/startupgov/imb.html
- Verify a recognition certificate: https://www.startupindia.gov.in/content/sih/en/startupgov/validate-startup-recognition.html
- Section 140, Income-tax Act, 2025: https://www.incometaxindia.gov.in/w/section-140-87
- ESOP taxation: https://www.incometaxindia.gov.in/w/taxation-of-employee-stock-option-plan-esop-
- Seed Fund Scheme: https://seedfund.startupindia.gov.in
- CGSS: https://www.startupindia.gov.in/content/sih/en/credit-guarantee-scheme-for-startups.html, NCGTC https://www.ncgtc.in and Jan Samarth https://www.jansamarth.in
- Fund of Funds (SIDBI): https://www.sidbi.in
- FC-GPR and other foreign investment filings (RBI FIRMS): https://firms.rbi.org.in
- Udyam registration: https://udyamregistration.gov.in
- StartupReader: https://startupreader.com/india-startup-schemes and the DPIIT lookup at https://startupreader.com/dpiit-lookup

## 12. Sources, wording differences and what is left out

Checked on 8 November 2026 against:
- startupindia.gov.in: the recognition page (startup_recognition_page.html), the 80-IAC form page (form80iac.html), the IMB page (imb.html) and the scheme page (startup-scheme.html).
- incometaxindia.gov.in: Section 140 and Section 392 of the Income-tax Act, 2025, and "Taxation of Employee Stock Option Plan (ESOP)".
- seedfund.startupindia.gov.in/about.
- StartupReader guides: dpiit-startup-recognition (checked 16 October 2026), section-80-iac-tax-exemption (19 October), credit-guarantee-scheme-for-startups (21 October), fund-of-funds-for-startups (29 October), udyam-msme-registration (30 October).
- StartupReader explainers (checked 28 October 2026): angel-tax-india, fdi-in-indian-startups, ccps-vs-ccd, reverse-flip-india; and 409a-valuation-and-fmv-india (22 October).

Wording differences, treated as "needs checking" at the exact limit:
- DPIIT turnover: the official page says "less than ₹200 crore"; StartupReader's guide says "not exceed".
- 80-IAC turnover: Startup India says "less than ₹100 crore in any financial year"; its declaration and the Act say "not exceeded" or "does not exceed", and the Act applies the test to the year claimed.
- 80-IAC incorporation date: some pages say "after 1 April 2016"; the Act and the IMB page say "on or after".

Left out because no official or StartupReader page could confirm it: the DeepTech definition, the ESOP deferral period for shares allotted from 1 April 2026, how long the IMB takes, and whether a three-year block that began in a past year can still be claimed.

#!/usr/bin/env python3
"""Startup India eligibility checks: DPIIT recognition, the Section 80-IAC tax
holiday, ESOP tax deferral, the Seed Fund Scheme and the Credit Guarantee
Scheme, from a company's facts.

Prints only the tests that depend on dates and thresholds (age limits, the
turnover limit in any financial year, the 80-IAC incorporation window, the
years a tax holiday could cover). Judgement calls such as innovation are
echoed as stated. Standard library only, no network access.

Usage:
  python scripts/eligibility.py assets/example-company.json
  python scripts/eligibility.py assets/example-company.json --only 80iac \
      --turnover 2029-30=1040000000
  python scripts/eligibility.py --entity private-limited --incorporated 2024-06-03 \
      --turnover 2024-25="18 lakh" --turnover 2025-26="1.2 crore" \
      [--name "Example Pvt Ltd"] [--as-of 2026-11-08] [--deep-tech no] \
      [--split no] [--used-plant no] [--innovation yes] [--recognised yes] \
      [--imb-certificate no] [--indian-promoters 100] [--govt-support 0] \
      [--foreign-investors no] [--in-default no] [--profit 2027-28=5000000]
      [--only dpiit|80iac|seed-fund|cgss|dates]

A JSON file uses the same facts with underscores (see assets/example-company.json);
arguments override the file. Yes/no facts take yes, no or unknown. Amounts are
rupees: 12500000, "1.25 crore" or "12.5 lakh". Financial years run from April to
March and are written 2025-26. Dates are YYYY-MM-DD.

Thresholds were last checked on 2026-11-08 (references/rules.md). Indian rules
change in Budgets, so confirm them on the official portals. Not tax or legal advice.
"""
import argparse
import json
import re
import sys
from datetime import date

LAKH = 100_000
CRORE = 10_000_000

# DPIIT startup definition, startupindia.gov.in recognition page (G.S.R. 108(E)).
DPIIT_MAX_AGE_YEARS = 10  # "considered a startup for up to 10 years ... from the date of its incorporation"
DPIIT_DEEPTECH_MAX_AGE_YEARS = 20  # "(20 years for DeepTech startups)"
DPIIT_TURNOVER_LIMIT = 200 * CRORE  # "less than INR 200 Crores ... in any of the previous financial years"
DPIIT_DEEPTECH_TURNOVER_LIMIT = 300 * CRORE  # "(INR 300 Crores for DeepTech startups)"

# Section 80-IAC of the Income-tax Act, 1961, now Section 140 of the Income-tax Act, 2025.
IAC_INCORPORATED_FROM = date(2016, 4, 1)  # Section 140(16)(b)(i): "on or after the 1st April, 2016"
IAC_INCORPORATED_BEFORE = date(2030, 4, 1)  # Section 140(16)(b)(i): "but before the 1st April, 2030"
IAC_MAX_AGE_YEARS = 10  # Startup India 80-IAC page: "Must be less than 10 years old"
IAC_TURNOVER_LIMIT = 100 * CRORE  # Startup India: "less than ₹100 crore in any financial year"; Act: "does not exceed" in the year claimed
IAC_WINDOW_YEARS = 10  # Section 140(2): "out of ten years beginning from the year in which the eligible start-up is incorporated"
IAC_HOLIDAY_YEARS = 3  # Section 140(2): "any three consecutive tax years"
IAC_GROWTH_1Y = 0.10  # Startup India declaration of scalability: "More than 10% growth in revenue from one financial year to the next"
IAC_GROWTH_2Y = 0.25  # "More than 25% cumulative growth in revenue over a period of two financial years"
IAC_GROWTH_3Y = 0.33  # "More than 33% cumulative growth in revenue over a period of three financial years"
IAC_USED_PLANT_SHARE = 0.20  # Section 140(6): used plant or machinery up to 20% of the total value is allowed

# Startup India Seed Fund Scheme, seedfund.startupindia.gov.in/about.
SEED_MAX_AGE_YEARS = 2  # "incorporated not more than 2 years ago at the time of application"
SEED_MIN_INDIAN_PROMOTERS_PCT = 51  # "Shareholding by Indian promoters ... at least 51%"
SEED_MAX_OTHER_SUPPORT = 10 * LAKH  # "should not have received more than Rs 10 lakh of monetary support"

OK, NO, CHECK = "Eligible", "Not eligible", "Needs checking"
RANK = {OK: 0, CHECK: 1, NO: 2}

# Entity type: (label, on the DPIIT list, can claim 80-IAC). None means "needs checking".
ENTITY_TYPES = {
    "private-limited": ("private limited company", True, True),
    "llp": ("limited liability partnership", True, True),
    "registered-partnership": ("registered partnership firm", True, False),
    "cooperative-society": ("cooperative society", True, False),
    "one-person-company": ("one person company", None, None),
    "public-limited": ("public limited company", False, False),
    "unregistered-partnership": ("unregistered partnership firm", False, False),
    "sole-proprietorship": ("sole proprietorship", False, False),
}
ALIASES = {
    "pvt-ltd": "private-limited",
    "private-limited-company": "private-limited",
    "limited-liability-partnership": "llp",
    "registered-partnership-firm": "registered-partnership",
    "co-operative-society": "cooperative-society",
    "opc": "one-person-company",
    "proprietorship": "sole-proprietorship",
}
BOOL_FACTS = ["deep_tech", "split_or_reconstructed", "reused_plant_or_machinery", "innovation",
              "dpiit_recognised", "imb_certificate", "foreign_investors", "in_default"]
KNOWN_FACTS = set(BOOL_FACTS) | {"name", "entity_type", "incorporated", "as_of", "turnover", "profit",
                                 "indian_promoters_pct", "other_government_support", "note"}
MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]


def fail(message):
    print(f"Error: {message}", file=sys.stderr)
    sys.exit(2)


def inr(amount):
    """Rupees in crore and lakh: ₹11.5 crore, ₹6.4 lakh, ₹45,000."""
    sign = "-" if amount < 0 else ""
    a = abs(amount)
    trim = lambda x: f"{x:.2f}".rstrip("0").rstrip(".")
    if a >= CRORE:
        return f"{sign}₹{trim(a / CRORE)} crore"
    if a >= LAKH:
        return f"{sign}₹{trim(a / LAKH)} lakh"
    return f"{sign}₹{round(a):,}"


def fmt(d):
    return f"{d.day} {MONTHS[d.month - 1]} {d.year}"


def parse_date(value, what):
    try:
        return date.fromisoformat(str(value).strip())
    except ValueError:
        fail(f"{what} must be a date written YYYY-MM-DD, got {value!r}")


def parse_bool(value, what):
    if value is None or isinstance(value, bool):
        return value
    s = str(value).strip().lower()
    if s in ("yes", "y", "true"):
        return True
    if s in ("no", "n", "false"):
        return False
    if s in ("unknown", "not stated", ""):
        return None
    fail(f"{what} must be yes, no or unknown, got {value!r}")


def parse_amount(value, what):
    if isinstance(value, bool):
        fail(f"{what} must be an amount in rupees, got {value!r}")
    if isinstance(value, (int, float)):
        return float(value)
    s = re.sub(r"^(₹|rs\.?|inr)\s*", "", str(value).strip().lower()).replace(",", "")
    m = re.fullmatch(r"(-?\d+(?:\.\d+)?)\s*(crores?|cr|lakhs?|lacs?)?", s)
    if not m:
        fail(f"{what} must be rupees, e.g. 12500000, \"1.25 crore\" or \"12.5 lakh\", got {value!r}")
    unit = m.group(2) or ""
    return float(m.group(1)) * (CRORE if unit.startswith("cr") else LAKH if unit.startswith("la") else 1)


def parse_fy(label):
    """'2025-26', 'FY 2025-26' or '2025-2026' -> 2025 (the year the FY starts in April)."""
    s = re.sub(r"^fy\s*", "", str(label).strip().lower())
    m = re.fullmatch(r"(\d{4})\s*[-/]\s*(\d{2}|\d{4})", s)
    if not m:
        fail(f"financial year must be written like 2025-26, got {label!r}")
    start, end = int(m.group(1)), m.group(2)
    if (len(end) == 2 and int(end) != (start + 1) % 100) or (len(end) == 4 and int(end) != start + 1):
        fail(f"financial year {label!r} must span two consecutive years, e.g. 2025-26")
    return start


def fy_of(d):
    """Indian financial years run 1 April to 31 March."""
    return d.year if d.month >= 4 else d.year - 1


def fy(start):
    return f"FY {start}-{(start + 1) % 100:02d}"


def add_years(d, n):
    try:
        return d.replace(year=d.year + n)
    except ValueError:  # 29 February: use 28 February
        return d.replace(year=d.year + n, day=28)


def age_text(start, end):
    months = (end.year - start.year) * 12 + end.month - start.month - (1 if end.day < start.day else 0)
    plural = lambda n, unit: f"{n} {unit}" + ("" if n == 1 else "s")
    parts = [plural(months // 12, "year")] if months >= 12 else []
    return " ".join(parts + [plural(months % 12, "month")])


def worst(statuses):
    return max(statuses, key=lambda s: RANK[s]) if statuses else OK


def line(status, text):
    return f"  {status:<15} {text}"


def by_year(raw, what, inc_fy, allow_negative):
    if raw is None:
        return {}
    if not isinstance(raw, dict):
        fail(f"{what} must map financial years to rupees, e.g. {{\"2025-26\": 12500000}}")
    out = {}
    for label, value in raw.items():
        start = parse_fy(label)
        if start < inc_fy:
            fail(f"{what} is given for {fy(start)}, before the company was incorporated ({fy(inc_fy)})")
        amount = parse_amount(value, f"{what} for {fy(start)}")
        if amount < 0 and not allow_negative:
            fail(f"{what} for {fy(start)} cannot be negative")
        out[start] = amount
    return out


def load_facts(args):
    facts = {}
    if args.facts:
        try:
            with open(args.facts, encoding="utf-8") as fh:
                facts = json.load(fh)
        except OSError as e:
            fail(f"cannot read {args.facts}: {e.strerror}")
        except json.JSONDecodeError as e:
            fail(f"{args.facts} is not valid JSON: {e}")
        if not isinstance(facts, dict):
            fail(f"{args.facts} must hold one JSON object of facts")
        unknown = sorted(set(facts) - KNOWN_FACTS)
        if unknown:
            fail(f"unknown fact(s) in {args.facts}: {', '.join(unknown)}. Known: {', '.join(sorted(KNOWN_FACTS))}")
    overrides = {
        "name": args.name, "entity_type": args.entity, "incorporated": args.incorporated, "as_of": args.as_of,
        "deep_tech": args.deep_tech, "split_or_reconstructed": args.split, "reused_plant_or_machinery": args.used_plant,
        "innovation": args.innovation, "dpiit_recognised": args.recognised, "imb_certificate": args.imb_certificate,
        "indian_promoters_pct": args.indian_promoters, "other_government_support": args.govt_support,
        "foreign_investors": args.foreign_investors, "in_default": args.in_default,
    }
    facts.update({k: v for k, v in overrides.items() if v is not None})
    for key, pairs in (("turnover", args.turnover), ("profit", args.profit)):
        for pair in pairs or []:
            if "=" not in pair:
                fail(f"--{key} takes FY=AMOUNT, e.g. 2025-26=12500000, got {pair!r}")
            label, value = pair.split("=", 1)
            facts[key] = dict(facts.get(key) or {}, **{label.strip(): value.strip()})

    if not facts.get("entity_type"):
        fail("the entity type is required (--entity or entity_type), e.g. private-limited")
    if not facts.get("incorporated"):
        fail("the incorporation date is required (--incorporated or incorporated), e.g. 2021-08-12")
    entity = re.sub(r"[\s_]+", "-", str(facts["entity_type"]).strip().lower())
    entity = ALIASES.get(entity, entity)
    if entity not in ENTITY_TYPES:
        fail(f"unknown entity type {facts['entity_type']!r}. Use one of: {', '.join(ENTITY_TYPES)}")
    f = {"name": facts.get("name") or "the company", "entity": entity}
    f["incorporated"] = parse_date(facts["incorporated"], "incorporated")
    f["as_of"] = parse_date(facts["as_of"], "as_of") if facts.get("as_of") else date.today()
    if f["incorporated"] > f["as_of"]:
        fail(f"incorporated ({f['incorporated']}) is after the as-of date ({f['as_of']})")
    for key in BOOL_FACTS:
        f[key] = parse_bool(facts.get(key), key)
    f["promoters"] = None
    if facts.get("indian_promoters_pct") is not None:
        f["promoters"] = parse_amount(facts["indian_promoters_pct"], "indian_promoters_pct")
        if not 0 <= f["promoters"] <= 100:
            fail("indian_promoters_pct is a percentage between 0 and 100, e.g. 82")
    f["support"] = None
    if facts.get("other_government_support") is not None:
        f["support"] = parse_amount(facts["other_government_support"], "other_government_support")
    inc_fy = fy_of(f["incorporated"])
    f["turnover"] = by_year(facts.get("turnover"), "turnover", inc_fy, allow_negative=False)
    f["profit"] = by_year(facts.get("profit"), "profit", inc_fy, allow_negative=True)
    return f


def check_dpiit(f):
    inc, asof, deep = f["incorporated"], f["as_of"], f["deep_tech"]
    label, on_list, _ = ENTITY_TYPES[f["entity"]]
    rows = []
    if on_list:
        rows.append((OK, f"Entity type: {label} is on the list"))
    elif on_list is None:
        rows.append((CHECK, f"Entity type: {label}; the list names private limited companies, so confirm on NSWS"))
    else:
        rows.append((NO, f"Entity type: {label} is not on the list (private limited, registered partnership, LLP, cooperative)"))

    limit, deep_limit = add_years(inc, DPIIT_MAX_AGE_YEARS), add_years(inc, DPIIT_DEEPTECH_MAX_AGE_YEARS)
    age = age_text(inc, asof)
    if asof < limit:
        rows.append((OK, f"Age {age}: the {DPIIT_MAX_AGE_YEARS}-year limit is reached on {fmt(limit)}"))
    elif deep and asof < deep_limit:
        rows.append((CHECK, f"Age {age}: passes only as DeepTech ({DPIIT_DEEPTECH_MAX_AGE_YEARS}-year limit, {fmt(deep_limit)}), which DPIIT decides"))
    else:
        years = DPIIT_DEEPTECH_MAX_AGE_YEARS if deep else DPIIT_MAX_AGE_YEARS
        rows.append((NO, f"Age {age}: the {years}-year limit passed on {fmt(deep_limit if deep else limit)}"))

    current = fy_of(asof)
    given = {y: t for y, t in f["turnover"].items() if y <= current}
    if not given:
        rows.append((CHECK, f"Turnover: none given; the {inr(DPIIT_TURNOVER_LIMIT)} limit applies to every FY since incorporation"))
    else:
        peak_fy = max(given, key=lambda y: (given[y], y))
        peak = given[peak_fy]
        where = f"peak {inr(peak)} ({fy(peak_fy)})"
        if peak < DPIIT_TURNOVER_LIMIT:
            rows.append((OK, f"Turnover: {where}; the limit is {inr(DPIIT_TURNOVER_LIMIT)} in any FY"))
        elif peak == DPIIT_TURNOVER_LIMIT:
            rows.append((CHECK, f"Turnover: {where}, exactly at the limit; sources say 'less than' and 'not exceed'"))
        elif deep and peak < DPIIT_DEEPTECH_TURNOVER_LIMIT:
            rows.append((CHECK, f"Turnover: {where}; passes only as DeepTech ({inr(DPIIT_DEEPTECH_TURNOVER_LIMIT)} limit)"))
        elif deep and peak == DPIIT_DEEPTECH_TURNOVER_LIMIT:
            rows.append((CHECK, f"Turnover: {where}, exactly at the DeepTech limit; sources say 'less than' and 'not exceed'"))
        else:
            rows.append((NO, f"Turnover: {where} is over the {inr(DPIIT_DEEPTECH_TURNOVER_LIMIT if deep else DPIIT_TURNOVER_LIMIT)} limit"))
        missing = [fy(y) for y in range(fy_of(inc), current) if y not in given]
        if missing:
            which = ", ".join(missing) if len(missing) <= 3 else f"{len(missing)} FYs from {missing[0]} to {missing[-1]}"
            rows.append((CHECK, f"No turnover given for {which}: the limit applies to every FY"))

    split = f["split_or_reconstructed"]
    rows.append({False: (OK, "Not formed by splitting up or reconstructing a business (as stated)"),
                 True: (NO, "Formed by splitting up or reconstructing an existing business"),
                 None: (CHECK, "Formed by splitting up or reconstructing a business? Not stated")}[split])
    rows.append({True: (OK, "Works on innovation or a scalable model (as stated; DPIIT judges it)"),
                 False: (NO, "Does not work on innovation, improvement or a scalable model (as stated)"),
                 None: (CHECK, "Innovation or scalability: not stated; DPIIT judges it")}[f["innovation"]])
    return worst([s for s, _ in rows]), rows


def recognition_row(f, dpiit_verdict):
    """The benefits below all need recognition, not just eligibility for it."""
    if dpiit_verdict == NO:
        return (NO, "Fails the DPIIT recognition tests above")
    if f["dpiit_recognised"] is not True:
        return (CHECK, "DPIIT recognition not held yet (or not stated): it comes first")
    return None


def growth_row(f):
    complete = sorted(y for y in f["turnover"] if y < fy_of(f["as_of"]))
    if len(complete) < 2:
        return (CHECK, "Revenue growth: needs turnover for two or more completed FYs")
    t = f["turnover"]
    last = complete[-1]
    tests = []
    for years, need in ((1, IAC_GROWTH_1Y), (2, IAC_GROWTH_2Y), (3, IAC_GROWTH_3Y)):
        base = t.get(last - years)
        if base:
            tests.append((years, need, t[last] / base - 1))
    if not tests:
        return (CHECK, f"Revenue growth: no earlier non-zero turnover to compare with {fy(last)}")
    for years, need, growth in tests:
        if growth > need:
            span = "the year before" if years == 1 else f"{years} years before"
            return (OK, f"Revenue growth {fy(last)}: {growth:+.1%} on {span} (needs over {need:.0%})")
    if any(abs(g - n) < 1e-9 for _, n, g in tests):
        return (CHECK, "Revenue growth exactly at a threshold: the declaration says 'more than'")
    years, need, growth = tests[0]
    return (CHECK, f"Revenue growth {fy(last)}: {growth:+.1%}, under every scalability test (over 10%, 25% or 33%)")


def check_80iac(f, dpiit_verdict):
    inc, asof = f["incorporated"], f["as_of"]
    label, _, can_claim = ENTITY_TYPES[f["entity"]]
    rows = []
    if can_claim:
        rows.append((OK, f"Company or LLP: {label}"))
    elif can_claim is None:
        rows.append((CHECK, f"{label.capitalize()}: the criteria name private limited companies and LLPs"))
    else:
        rows.append((NO, f"Only private limited companies and LLPs can claim it, not a {label}"))
    in_window = IAC_INCORPORATED_FROM <= inc < IAC_INCORPORATED_BEFORE
    rows.append((OK if in_window else NO,
                 f"Incorporated {fmt(inc)}: needs {fmt(IAC_INCORPORATED_FROM)} to {fmt(date(2030, 3, 31))}"))
    ten = add_years(inc, IAC_MAX_AGE_YEARS)
    rows.append((OK, f"Under {IAC_MAX_AGE_YEARS} years old until {fmt(ten)}") if asof < ten
                else (NO, f"{IAC_MAX_AGE_YEARS} years old on {fmt(ten)}: too old to apply"))
    current = fy_of(asof)
    given = {y: t for y, t in f["turnover"].items() if y <= current}
    if given:
        peak_fy = max(given, key=lambda y: (given[y], y))
        peak = given[peak_fy]
        if peak < IAC_TURNOVER_LIMIT:
            rows.append((OK, f"Turnover under {inr(IAC_TURNOVER_LIMIT)} in every FY to date (peak {inr(peak)})"))
        elif peak == IAC_TURNOVER_LIMIT:
            rows.append((CHECK, f"Turnover exactly {inr(peak)} in {fy(peak_fy)}: Startup India says 'less than'"))
        else:
            rows.append((NO, f"Turnover {inr(peak)} in {fy(peak_fy)}: Startup India needs under {inr(IAC_TURNOVER_LIMIT)} in every FY"))
    split, plant = f["split_or_reconstructed"], f["reused_plant_or_machinery"]
    if split is True:
        rows.append((NO, "Formed by splitting up or reconstructing an existing business"))
    elif plant is True:
        rows.append((CHECK, f"Uses plant or machinery used before: allowed up to {IAC_USED_PLANT_SHARE:.0%} of the total value"))
    elif split is False and plant is False:
        rows.append((OK, "No splitting up, reconstruction or used plant and machinery (as stated)"))
    else:
        rows.append((CHECK, "Splitting up, reconstruction or used plant and machinery: not stated"))
    rows.append(growth_row(f))
    rec = recognition_row(f, dpiit_verdict)
    if rec:
        rows.append(rec)
    rows.append((OK, "IMB certificate held") if f["imb_certificate"]
                else (CHECK, "IMB certificate not held yet: apply on the Startup India portal"))
    return worst([s for s, _ in rows]), rows, in_window


def holiday_blocks(f):
    """Ten FYs from the FY of incorporation; any three consecutive ones."""
    first, current = fy_of(f["incorporated"]), fy_of(f["as_of"])
    last = first + IAC_WINDOW_YEARS - 1
    starts = list(range(first, last - IAC_HOLIDAY_YEARS + 2))
    past = [s for s in starts if s < current]
    future = [s for s in starts if s >= current]
    out = [f"  Ten-year window {fy(first)} to {fy(last)} (ends {fmt(date(last + 1, 3, 31))})."]
    if future:
        out = [f"  Ten-year window {fy(first)} to {fy(last)}. Three-year blocks (profit as given; losses count as zero):"]
        sums = {}
        for s in future:
            years = range(s, s + IAC_HOLIDAY_YEARS)
            over = [y for y in years if f["turnover"].get(y, 0) > IAC_TURNOVER_LIMIT]
            gaps = [y for y in years if y not in f["profit"]]
            sums[s] = sum(max(0.0, f["profit"].get(y, 0.0)) for y in years if y not in over)
            notes = []
            if over:
                notes.append(f"{', '.join(fy(y) for y in over)} left out: turnover over {inr(IAC_TURNOVER_LIMIT)}")
            if gaps and len(gaps) < IAC_HOLIDAY_YEARS:
                notes.append(f"no profit given for {', '.join(fy(y) for y in gaps)}")
            text = inr(sums[s]) if len(gaps) < IAC_HOLIDAY_YEARS else "no profit given"
            out.append((s, f"    {fy(s)} to {fy(s + 2)}   {text}" + (f"  ({'; '.join(notes)})" if notes else "")))
        best = max(sums, key=lambda s: (sums[s], -s)) if any(sums.values()) else None
        out = [o if isinstance(o, str) else o[1] + ("  <- largest" if o[0] == best else "") for o in out]
    if past:
        span = fy(past[0]) if len(past) == 1 else f"{fy(past[0])} to {fy(past[-1])}"
        out.append(f"  Blocks starting {span} began in past years: ask a CA if any can still be claimed.")
    return out


def check_seed(f, dpiit_verdict):
    rows = []
    rec = recognition_row(f, dpiit_verdict)
    if rec:
        rows.append(rec)
    deadline = add_years(f["incorporated"], SEED_MAX_AGE_YEARS)
    rows.append((OK, f"Within {SEED_MAX_AGE_YEARS} years of incorporation: apply by {fmt(deadline)}") if f["as_of"] <= deadline
                else (NO, f"Must apply within {SEED_MAX_AGE_YEARS} years of incorporation: that passed on {fmt(deadline)}"))
    p = f["promoters"]
    if p is None:
        rows.append((CHECK, f"Indian promoters' shareholding not stated (needs at least {SEED_MIN_INDIAN_PROMOTERS_PCT}%)"))
    else:
        rows.append((OK if p >= SEED_MIN_INDIAN_PROMOTERS_PCT else NO,
                     f"Indian promoters hold {p:g}% (needs at least {SEED_MIN_INDIAN_PROMOTERS_PCT}%)"))
    s = f["support"]
    if s is None:
        rows.append((CHECK, f"Other government monetary support not stated (limit {inr(SEED_MAX_OTHER_SUPPORT)})"))
    else:
        rows.append((OK if s <= SEED_MAX_OTHER_SUPPORT else NO,
                     f"Other government monetary support {inr(s)} (limit {inr(SEED_MAX_OTHER_SUPPORT)})"))
    return worst([st for st, _ in rows]), rows


def check_cgss(f, dpiit_verdict):
    rows = []
    rec = recognition_row(f, dpiit_verdict)
    if rec:
        rows.append(rec)
    rows.append({False: (OK, "Not in default or an NPA (as stated)"),
                 True: (NO, "In default or classed as an NPA"),
                 None: (CHECK, "Default or NPA status not stated")}[f["in_default"]])
    rows.append((CHECK, "Stable revenue over 12 months and the loan itself: the lender assesses them"))
    return worst([s for s, _ in rows]), rows


def main():
    parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    parser.add_argument("facts", nargs="?", help="JSON file of facts, e.g. assets/example-company.json")
    parser.add_argument("--name")
    parser.add_argument("--entity", help=", ".join(ENTITY_TYPES))
    parser.add_argument("--incorporated", help="YYYY-MM-DD")
    parser.add_argument("--as-of", dest="as_of", help="date to check on, YYYY-MM-DD (default today)")
    parser.add_argument("--turnover", action="append", metavar="FY=AMOUNT", help="repeat per FY, e.g. 2025-26=115000000")
    parser.add_argument("--profit", action="append", metavar="FY=AMOUNT", help="eligible-business profit, actual or projected")
    for flag, dest in (("--deep-tech", "deep_tech"), ("--split", "split"), ("--used-plant", "used_plant"),
                       ("--innovation", "innovation"), ("--recognised", "recognised"),
                       ("--imb-certificate", "imb_certificate"), ("--foreign-investors", "foreign_investors"),
                       ("--in-default", "in_default")):
        parser.add_argument(flag, dest=dest, metavar="yes|no|unknown")
    parser.add_argument("--indian-promoters", dest="indian_promoters", metavar="PCT", help="Indian promoters' shareholding, %%")
    parser.add_argument("--govt-support", dest="govt_support", metavar="AMOUNT", help="money from other government schemes")
    parser.add_argument("--only", choices=["dpiit", "80iac", "seed-fund", "cgss", "dates"])
    args = parser.parse_args()
    f = load_facts(args)
    show = lambda part: args.only in (None, part)

    inc, asof = f["incorporated"], f["as_of"]
    label = ENTITY_TYPES[f["entity"]][0]
    out = [f"Startup India eligibility: {f['name']}",
           f"As of {fmt(asof)} ({fy(fy_of(asof))}). {label[0].upper() + label[1:]}, incorporated {fmt(inc)}."]
    dpiit_verdict, rows = check_dpiit(f)
    if show("dpiit"):
        held = {True: "yes", False: "no", None: "not stated"}[f["dpiit_recognised"]]
        out += ["", f"DPIIT recognition: {dpiit_verdict} (recognition held: {held})"] + [line(*r) for r in rows]
    iac_verdict, rows, in_window = check_80iac(f, dpiit_verdict)
    in_window = in_window and iac_verdict != NO  # no holiday window to plan once a test fails
    if show("80iac"):
        out += ["", f"Section 80-IAC tax holiday (Section 140, Income-tax Act, 2025): {iac_verdict}"]
        out += [line(*r) for r in rows] + (holiday_blocks(f) if in_window else [])
        esop = NO if iac_verdict == NO else OK if f["imb_certificate"] and iac_verdict == OK else CHECK
        out.append(f"ESOP tax deferral for employees: {esop} (only at a start-up with the IMB certificate)")
    if show("seed-fund"):
        verdict, rows = check_seed(f, dpiit_verdict)
        out += ["", f"Startup India Seed Fund Scheme: {verdict}"] + [line(*r) for r in rows]
    if show("cgss"):
        verdict, rows = check_cgss(f, dpiit_verdict)
        out += ["", f"Credit Guarantee Scheme for Startups: {verdict}"] + [line(*r) for r in rows]
    if show("dates"):
        seed = add_years(inc, SEED_MAX_AGE_YEARS)
        dates = [(add_years(inc, DPIIT_MAX_AGE_YEARS), f"DPIIT age limit ({DPIIT_MAX_AGE_YEARS} years from incorporation)"),
                 (seed, "Last day to apply to the Seed Fund Scheme" + (" (passed)" if asof > seed else ""))]
        if f["deep_tech"]:
            dates.append((add_years(inc, DPIIT_DEEPTECH_MAX_AGE_YEARS), f"DeepTech age limit ({DPIIT_DEEPTECH_MAX_AGE_YEARS} years)"))
        if in_window:
            last = fy_of(inc) + IAC_WINDOW_YEARS - 1
            dates.append((date(last + 1, 3, 31), f"End of the 80-IAC ten-year window ({fy(last)})"))
        out += ["", "Key dates"] + [f"  {fmt(d):<12}  {text}" for d, text in sorted(dates)]
        if f["foreign_investors"]:
            out.append(f"Foreign investors: yes. Seed Fund needs Indian promoters at {SEED_MIN_INDIAN_PROMOTERS_PCT}%+;"
                       " FEMA pricing and FC-GPR apply.")
    print("\n".join(out))


if __name__ == "__main__":
    if hasattr(sys.stdout, "reconfigure"):
        try:
            sys.stdout.reconfigure(encoding="utf-8")
        except (ValueError, OSError):
            pass
    main()