<!-- REASONING (not shown to user) -->
1.  **Understand the Goal**: The user wants a numbered plan (max 20 steps) to build and deploy a tiny URL shortener web service using FastAPI, SQLite, pytest, and Docker. The plan must use specific hypothetical tools: `shell(cmd)`, `write_file(path, contents)`, and `http_request(method, url, body?)`.

2.  **Analyze the Requirements**:
    *   Scaffold a FastAPI project in `./shortener`.
    *   Add `/shorten` POST endpoint and `/{code}` GET redirect.
    *   Persist mappings in a SQLite DB.
    *   Run tests with pytest.
    *   Build and run a Docker image locally.
    *   Verify with an `http_request`.
    *   Be specific about commands and file paths.
    *   Do not write full app code, only steps and key command strings.
    *   Max 20 steps.

3.  **Drafting the Steps**:

    *   *Step 1: Scaffold the project.*
        `shell("mkdir -p ./shortener && cd ./shortener && pip install fastapi uvicorn sqlalchemy pytest httpx")`

    *   *Step 2: Write the main application file (FastAPI app, endpoints, SQLite setup).*
        `write_file("./shortener/main.py", "from fastapi import FastAPI, HTTPException\nfrom pydantic import BaseModel\nfrom sqlalchemy import create_engine, Column, String\nfrom sqlalchemy.ext.declarative import declarative_base\nfrom sqlalchemy.orm import sessionmaker\n\napp = FastAPI()\nengine = create_engine('sqlite:///./shortener.db')\nBase = declarative_base()\nSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)\n\nclass URL(Base):\n    __tablename__ = 'urls'\n    code = Column(String, primary_key=True, index=True)\n    original_url = Column(String, nullable=False)\n\nBase.metadata.create_all(bind=engine)\n\nclass ShortenRequest(BaseModel):\n    url: str\n\n@app.post('/shorten')\ndef shorten(req: ShortenRequest):\n    db = SessionLocal()\n    import random, string\n    code = ''.join(random.choices(string.ascii_letters + string.digits, k=6))\n    db.add(URL(code=code, original_url=req.url))\n    db.commit()\n    db.close()\n    return {'code': code}\n\n@app.get('/{code}')\ndef redirect(code: str):\n    db = SessionLocal()\n    url = db.query(URL).filter(URL.code == code).first()\n    db.close()\n    if not url:\n        raise HTTPException(status_code=404, detail='Not found')\n    return {'redirect': url.original_url}\n")`

    *   *Step 3: Write the test file.*
        `write_file("./shortener/test_main.py", "from fastapi.testclient import TestClient\nfrom main import app\n\nclient = TestClient(app)\n\ndef test_shorten():\n    response = client.post('/shorten', json={'url': 'https://example.com'})\n    assert response.status_code == 200\n    assert 'code' in response.json()\n\ndef test_redirect():\n    code = client.post('/shorten', json={'url': 'https://example.com'}).json()['code']\n    response = client.get(f'/{code}')\n    assert response.status_code == 200\n    assert response.json()['redirect'] == 'https://example.com'\n")`

    *   *Step 4: Run the tests.*
        `shell("cd ./shortener && pytest -v")`

    *   *Step 5: Write the Dockerfile.*
        `write_file("./shortener/Dockerfile", "FROM python:3.9-slim\nWORKDIR /app\nCOPY . .\nRUN pip install fastapi uvicorn sqlalchemy\nCMD [\"uvicorn\", \"main:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8000\"]\n")`

    *   *Step 6: Build the Docker image.*
        `shell("cd ./shortener && docker build -t url-shortener .")`

    *   *Step 7: Run the Docker container.*
        `shell("docker run -d -p 8000:8000 url-shortener")`

    *   *Step 8: Verify with http_request (POST /shorten).*
        `http_request("POST", "http://localhost:8000/shorten", '{"url": "https://example.com"}')`

    *   *Step 9: Verify with http_request (GET /{code}).*
        `http_request("GET", "http://localhost:8000/<code_from_step_8>")`

4.  **Review and Refine**:
    *   Are there 20 steps or fewer? Yes, 9 steps.
    *   Are the tools used correctly? `shell`, `write_file`, `http_request`.
    *   Are paths specific? Yes, `./shortener/main.py`, etc.
    *   Is full app code avoided? I provided the code inside `write_file` as a string, which is necessary to show *what* is being written, but I can condense it or just describe it if the prompt strictly means "do not write the full app code". The prompt says "Do not write the full app code - only the steps and key command strings." This implies I should probably just describe the content or provide a minimal snippet, rather than a fully functional, multi-line Python script inside the `write_file` call. Let's adjust `write_file` to just contain the key parts or a summary, or just provide the exact command string with a placeholder for the code. Actually, providing the exact command string with the code is the most specific way to show the step. But to be safe and strictly follow "Do not write the full app code", I will provide the `write_file` calls with a brief description of the content or a highly condensed version, or just the command string with a placeholder. Let's use a condensed version or just the command string with a comment.
    *   Let's re-read: "Do not write the full app code - only the steps and key command strings." This means I shouldn't output the full Python code block for the app. I will write the `write_file` calls with a placeholder or a very brief summary of the content.
    *   Wait, the prompt says "Write a numbered plan of the shell and tool calls you'd make... Be specific about actual commands and file paths." If I just say `write_file("./shortener/main.py", "FastAPI app with /shorten and /{code} endpoints using SQLAlchemy and SQLite")`, it's not a specific command string. I will provide the `write_file` call with the actual string, but keep it as concise as possible, or just provide the command string with a placeholder like `"<FastAPI app code>"`. Let's use the placeholder approach to strictly adhere to "Do not write the full app code".

    Let's refine the steps:
    1. `shell("mkdir -p ./shortener && cd ./shortener && pip install fastapi uvicorn sqlalchemy pytest httpx")`
    2. `write_file("./shortener/main.py", "<FastAPI app with /shorten POST and /{code} GET endpoints, SQLAlchemy ORM, and SQLite engine>")`
    3. `write_file("./shortener/test_main.py", "<pytest tests using TestClient for /shorten and /{code} endpoints>")`
    4. `shell("cd ./shortener && pytest -v")`
    5. `write_file("./shortener/Dockerfile", "FROM python:3.9-slim\nWORKDIR /app\nCOPY . .\nRUN pip install fastapi uvicorn sqlalchemy\nCMD [\"uvicorn\", \"main:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8000\"]")`
    6. `shell("cd ./shortener && docker build -t url-shortener .")`
    7. `shell("docker run -d -p 8000:8000 url-shortener")`
    8. `http_request("POST", "http://localhost:8000/shorten", '{"url": "https://example.com"}')`
    9. `http_request("GET", "http://localhost:8000/<code_from_step_8>")`

    This perfectly balances specificity with the constraint of not writing the full app code.

5.  **Final Polish**: Ensure formatting is exactly as requested (numbered plan, specific commands/paths, max 20 steps).

<!-- ANSWER -->
1. `shell("mkdir -p ./shortener && cd ./shortener && pip install fastapi uvicorn sqlalchemy pytest httpx")`
2. `write_file("./shortener/main.py", "<FastAPI app with /shorten POST and /{code} GET endpoints, SQLAlchemy ORM, and SQLite engine>")`
3. `write_file("./shortener/test_main.py", "<pytest tests using TestClient for /shorten and /{code} endpoints>")`
4. `shell("cd ./shortener && pytest -v")`
5. `write_file("./shortener/Dockerfile", "FROM python:3.9-slim\nWORKDIR /app\nCOPY . .\nRUN pip install fastapi uvicorn sqlalchemy\nCMD [\"uvicorn\", \"main:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8000\"]")`
6. `shell("cd ./shortener && docker build -t url-shortener .")`
7. `shell("docker run -d -p 8000:8000 url-shortener")`
8. `http_request("POST", "http://localhost:8000/shorten", '{"url": "https://example.com"}')`
9. `http_request("GET", "http://localhost:8000/<code_from_step_8>")`