Context Navigation

-              ra531b45
+              ref1c1c7
 ## Name of AI service/solution that was used
+**Claude Code** (Anthropic)
+**Claude Code** (Anthropic), an AI coding assistant that runs in the terminal and reads and
+edits the project files.
 - **URL:** https://claude.com/claude-code
+- **Type of service/subscription:** Claude subscription, model Claude Opus 4.7 (1M context).
+- **Type of service/subscription:** Claude subscription (Claude Code CLI). A different model was
+  used in each session:
+| Session | Date | Model |
+|---------|------|-------|
+| 1 | 2026-04-21 | Claude Opus 4.7 (1M context) |
+| 2 | 2026-08-06 / 2026-08-07 | Claude Opus 5 (1M context) |
+| 3 | 2026-09-16 | Claude Sonnet 5 |
+| 4 | 2026-09-24 | Claude Opus 5.5 (1M context) |
+The same sessions also worked on other phases. This page covers only what concerns the P4
+prototype and its documentation.
 ## Final result
 …
 ### Results in details / description
+During the 2026-04-21 session the AI:
+- Replaced the broken HTTP + frontend scaffolding (which the student had already decided to drop) with a single-binary CLI prototype in Go, split across `main.go`, `cli.go`, `auth.go`, `account.go`, `market.go`, `trade.go`, `portfolio.go`, `watchlist.go`.
+- Consolidated the broken `db.go` — which used to drop every table on every startup — into a single `Connect()` plus explicit `-init` and `-load-data` flags.
+- Moved `go.mod` from `server/` to the project root so the same module graph covers both `server/` and `bots/`.
+- Fixed `go.mod`: removed the unused MySQL driver, promoted `github.com/lib/pq` to a direct dependency.
+- Implemented the trade flows as real database transactions with row-level `FOR UPDATE` locks, cost-basis bookkeeping, and a ledger row per operation.
+- Wrote a 140-line market-simulation bot that inserts trades and upserts 1-minute candles every tick.
+- Exercised the full prototype end-to-end against a running PostgreSQL on port 5433 and verified a sample buy and portfolio view produced the expected numbers.
+**My own starting code (before any AI was used).** Before session 1 I had written:
+- a Go backend with HTTP handlers (Chi router);
+- a draft database schema (`server/db/db.sql`, `server/db/schema.sql`) and a diagram description
+  (`docs/dbdiagram.md`), based on my data model in `ep-diagram.md`;
+- a `main.go` / `db.go` that connected to PostgreSQL and dropped and recreated every table on
+  each start;
+- a half-finished frontend, which I deleted myself at the start of session 1 because the
+  prototype does not need it.
+This code is older than the git repository. The first commit (2026-08-07) was made after
+sessions 1 and 2, so the history in git starts from the AI-improved version. My original files
+are not in the repository. What they contained, and which errors the AI found in them, is
+recorded in the session 1 log below and in [ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md).
+**Session 1 (2026-04-21).** Starting from that code, the AI:
+- replaced my HTTP backend and the frontend scaffolding with a single-binary CLI prototype in Go,
+  split across `main.go`, `cli.go`, `auth.go`, `account.go`, `market.go`, `trade.go`,
+  `portfolio.go` and `watchlist.go`. This followed my decision to make a CLI and not a web app;
+- corrected my schema. `crypto_id` had been declared as a foreign key to two tables at once in
+  `holdings`, `orders` and `transactions`, and `market_candles` referenced a `markets` table that
+  did not exist. The corrected schema became `schema_creation.sql`, with the sample data in
+  `data_load.sql`;
+- replaced my `db.go`, which dropped every table on every start, with one `Connect()` plus
+  explicit `-init` and `-load-data` flags;
+- moved `go.mod` to the project root, removed an unused MySQL driver, and made
+  `github.com/lib/pq` a direct dependency;
+- wrote the trade flows as database transactions with `FOR UPDATE` row locks, cost-basis
+  bookkeeping and one ledger row per operation;
+- wrote the market-simulation bot (`bots/main.go`), after I decided to keep a market simulator
+  in the project.
+**Session 2 (2026-08-06/07).** I asked for a code review. The AI found and fixed three bugs
+(`.env`/SQL path resolution, an endless loop at end of input, and a wrong error check on the
+sell path). It also replaced the read-modify-write holding update with one
+`INSERT … ON CONFLICT DO UPDATE`, removed the committed `TerraER3.11.jar` and a TradingView
+screenshot we had no licence for, and wrote the first version of the P4 pages.
+**Session 3 (2026-09-16).** From an edge case I described, the AI added
+`holdings.reserved_quantity`, made the sell path reserve and then settle, and gave
+`orders.status` a real `open` → `executed` lifecycle.
+**Session 4 (2026-09-24).** I asked whether P4 fulfils the course rules. The AI found that the
+prototype still asked the user to type a market symbol and crypto symbols, which breaks the rule
+that the user must never have to remember identifiers or codes. It changed every choice to a
+numbered list (`market.go`, `trade.go`, `watchlist.go`), retook every screenshot, one per
+scenario step, and rewrote the P4 pages.
 ### Test evidence
+This is the current prototype (after session 4) on fresh sample data, logged in as `alice`. It
+is a real run, and the same run is on the screenshots of
+[UseCase0004Implementation](UseCase0004Implementation.md):
 ```
+-- Place market buy order --
+  #     Symbol    Quote       Last price
+  -----------------------------------------
+     ADA       USD           0.453750
+     BTC       USD       67140.000000
+     DOGE      USD           0.122000
+     ETH       USD        3520.000000
+     SOL       USD         166.100000
+Market #: 2
+Latest price for BTC/USD = 67140.000000
+Quantity: 0.01
 Order executed: buy 0.0100 BTC @ 67140.000000 (notional 671.4000 USD)
+  Symbol        Quantity         Avg buy         Current           Value  Unrealised P/L
+  BTC             0.0100    67140.000000    67140.000000        671.4000         +0.0000
+  ETH             0.5000     3500.000000     3520.000000       1760.0000        +10.0000
+  TOTAL                                                        2431.4000        +10.0000
+  Symbol        Quantity      Reserved     Available         Avg buy         Current           Value  Unrealised P/L
+  ------------------------------------------------------------------------------------------------------------------
+  BTC             0.0100        0.0000        0.0100    67140.000000    67140.000000        671.4000         +0.0000
+  ETH             0.5000        0.0000        0.5000     3500.000000     3520.000000       1760.0000        +10.0000
+  ------------------------------------------------------------------------------------------------------------------
+  TOTAL                                                                                    2431.4000        +10.0000
   Cash available : 7578.6000 USD
 …
 ## Summary of AI involvement
+| | Session 1 — 2026-04-21 | Session 2 — 2026-08-06/07 | Session 3 — 2026-09-16 |
+|---|---|---|---|
+| **What I brought** | My existing Go backend (Chi HTTP handlers) and a half-finished frontend | The CLI prototype as it stood after session 1 | A design review: the sell path had no way to reserve crypto committed to an order |
+| **What the AI did** | Rewrote the backend as a CLI covering UC0001–UC0007, wrote the market bot | Reviewed the code, found and fixed three bugs, improved the holding upsert | Added `holdings.reserved_quantity`, changed the sell path to reserve-then-settle, gave `Orders.status` a real lifecycle, tested it live including under real concurrency |
+| **What I decided** | To delete the frontend, to build a CLI rather than a web app, to keep the market simulator | To ask for a code review pass rather than documentation alone | To keep reserve+settle in one transaction rather than split it across two, since there is no cancel-order use case to recover a stuck reservation |
+The prototype was built in session 1 and worked. What session 2 added was a
+review pass I asked for specifically because I have to defend this code in
+person: it turned up a path-resolution bug that made my own documented build
+instructions fail, an infinite loop at end of input, and an error check in the
+wrong order that misreported database failures as "Insufficient holding".
+| | Session 1 — 2026-04-21 | Session 2 — 2026-08-06/07 | Session 3 — 2026-09-16 | Session 4 — 2026-09-24 |
+|---|---|---|---|---|
+| **What I brought** | My Go backend (Chi HTTP handlers), draft schema, a half-finished frontend | The CLI prototype as it stood after session 1 | A design review: the sell path had no way to reserve crypto committed to an order | The official P4 instructions and the question whether the prototype and pages meet them |
+| **What the AI did** | Rewrote the backend as a CLI covering UC0001–UC0007, corrected the schema, wrote the market bot | Reviewed the code, found and fixed three bugs, improved the holding upsert | Added `holdings.reserved_quantity`, reserve-then-settle sell path, `orders.status` lifecycle, tested it including real concurrency | Audited P4, made every choice a numbered list, retook all screenshots, rewrote the P4 pages |
+| **What I decided** | To delete the frontend, to build a CLI and not a web app, to keep the market simulator | To ask for a code review and not only documentation | To keep reserve and settle in one transaction, because there is no cancel-order use case to free a stuck reservation | To fix the problems found and to have the screenshots taken from real runs |
 ## Entire AI usage log
+See [ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md) for the full prompt/response transcript of the 2026-04-21 session — that single conversation produced all of the P1–P4 artefacts. The defining student prompt for P4 was:
+**About this log.** Sessions 3 and 4 are still in my local Claude Code history, so their
+prompts are quoted **verbatim** below, typos included. The local history of sessions 1 and 2
+(April and August 2026) is no longer available. For them, the prompts are the excerpts I wrote
+down at the time, the same ones as on [ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md),
+where they were logged because the same conversation produced P1–P4. The AI's responses are
+summarised, because several ran to many pages of code and file edits.
+---
+### Session 1 — 2026-04-21 (Claude Opus 4.7, 1M context)
+**Prompt (student, excerpt):**
+> This is my project for my exam Database, go to the docs folder and README.md there you will find all of the documentation, afterwards take a look at the whole project. Delete everything you want add everything you want just make it work and make it fill in or to follow all of the needed instructions. Ask me anything, also tell me what do I need to do
+**Response (AI, summarised):**
+- Read `docs/opis.md`, `docs/ep-diagram.md`, `docs/dbdiagram.md`, `server/db/db.sql`,
+  `server/db/schema.sql` and all Go sources.
+- Found errors in my schema: `holdings.crypto_id` declared as a foreign key to both
+  `users(id)` and `crypto(id)` (and the same mistake in `orders` and `transactions`), and
+  `market_candles` referencing a non-existent `markets` table. Also found that `main.go` dropped
+  and recreated all tables on every start, wiping the data.
+- Asked me to decide on team composition, prototype shape (CLI or HTTP), which columns to keep,
+  which use cases to implement, and the documentation language.
+**Prompt (student, excerpt):**
+> Read it now, just filled it in, also deleted the frontend we don' need that
+**Response (AI, summarised):**
+- Re-read `docs/README.md`, which now contained the course rubric, and explained the AI rules
+  per phase and the deliverables of each phase.
+**Prompt (student, excerpt):**
 > do everything that you need to do, and tell me after what do I need to do
+which translated into the rewrite of the backend and the writing of this documentation.
+> **Student action required:** append any further prompts here where you asked the AI to debug, extend, or refactor the prototype.
+### Session 2 — 2026-08-06 / 2026-08-07
+Prompts are logged in full in [ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md#session-2--2026-08-06--2026-08-07).
+The student asked the AI to complete the phase documentation and to *"fix some
+database things or golang things if you think we can do it better"*. What the AI
+changed in the prototype, and why:
+**Response (AI, summarised):**
+- Rewrote the backend as the CLI prototype (UC0001–UC0007), with the corrected
+  `schema_creation.sql`, `data_load.sql`, the new `db.go` with `-init` / `-load-data`, the
+  transactional trade flows and the market bot. The details are under *Results in details*
+  above.
+- Ran the prototype end to end against PostgreSQL on port 5433 and checked that a sample buy
+  and the portfolio view gave the expected numbers.
+---
+### Session 2 — 2026-08-06 / 2026-08-07 (Claude Opus 5, 1M context)
+**Prompt (student, excerpt):**
+> […] do all of the other Phases till m0.
+> opis.md It's p0 so I will take care of that. Delete anything that we don't need,
+> make all of the phases and terra diagram if you can, and delete anything
+> that we don't need and make a documentation about how to start it.
+**Prompt (student, excerpt, follow-up):**
+> Also fix some database things or golang things if you think we can do it better,
+**Response (AI, summarised): what changed in the prototype, and why**
 **Bugs found and fixed**
+. `server/db/db.go` resolved `../.env` and `db/schema_creation.sql` as paths
+   relative to the working directory, so they only worked when the program was
+   started from inside `server/`. Following the documented instructions — build
+   from the repository root and run `./eduberza -init` — failed with
+   `password authentication failed for user "postgres"`, because the `.env` file
+   was never found and the defaults were used. The two SQL scripts are now
+   compiled into the binary with `go:embed`, and `.env` is located by searching
+   the working directory and every parent. Real environment variables now take
+   precedence over the file, which is what allows the prototype to be pointed at
+   the faculty database without editing anything.
+. `prompt()` in `server/cli.go` ignored the error from `ReadString`. At end of
+   input — Ctrl-D, or a scripted run — it returned an empty string forever and
+   the menu loop spun printing "Unknown option." without end. It now exits
+   cleanly.
+. On the sell path, `trade.go` checked `err == sql.ErrNoRows || held < qty`
+   before checking for other errors, so any scan failure was reported to the user
+   as "Insufficient holding" regardless of the real cause. The error check now
+   comes first.
+. `server/db/db.go` resolved `../.env` and `db/schema_creation.sql` relative to the working
+   directory, so they only worked when the program was started from inside `server/`.
+   Following the documented instructions (build from the repository root and run
+   `./eduberza -init`) failed with `password authentication failed for user "postgres"`,
+   because `.env` was never found and the defaults were used. The two SQL scripts are now
+   compiled into the binary with `go:embed`, and `.env` is searched for in the working directory
+   and every parent. Real environment variables now take precedence over the file.
+. `prompt()` in `server/cli.go` ignored the error from `ReadString`. At end of input (Ctrl-D,
+   or a scripted run) it returned an empty string forever, and the menu loop kept printing
+   "Unknown option." without end. It now exits cleanly.
+. On the sell path, `trade.go` checked `err == sql.ErrNoRows || held < qty` before checking
+   for other errors, so any scan failure was reported as "Insufficient holding". The error
+   check now comes first.
 **Improvements**
+. The holding upsert was a read-modify-write in Go (`SELECT ... FOR UPDATE`,
+   compute the new weighted average in `float64`, then `INSERT` or `UPDATE`). It
+   is now a single `INSERT … ON CONFLICT (user_id, crypto_id) DO UPDATE`, so the
+   average is recomputed by PostgreSQL in `numeric` arithmetic and the statement
+   relies on the unique constraint that the relational design already declared.
+. `TerraER3.11.jar` was removed from the repository and `.gitignore` now
+   excludes `*.jar`, because P4 requires third-party executables to be
+   downloaded rather than committed. `.env` is excluded too and `.env.example`
+   was added in its place.
+. `image.png`, a TradingView screenshot, was deleted — the project has no
+   licence to publish it and P4 requires explicit usage rights.
+**Verification**
+All seven use cases were executed against a live PostgreSQL 16 database. The
+screenshots on the `UseCaseXXXXImplementation` pages are captures of those runs.
+The four failure paths were tested, and the rollback behaviour was checked
+directly in SQL: after a rejected purchase, the affected user has zero rows in
+`orders`, `transactions` and `holdings`.
+> **Student action required:** read the changed files (`server/db/db.go`,
+> `server/cli.go`, `server/trade.go`, `server/db/schema_creation.sql`) before the
+> presentation. You will be asked how the buy transaction works, and the answer
+> has to be yours.
+### Session 3 — 2026-09-16
+Prompted by a design review I did myself, logged in full in
+[ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md#session-3--2026-09-16).
+The report: a user who owns 2 BTC and places a sell order for 0.5 BTC has that
+crypto immediately removed from `quantity`, but nothing in the model recorded
+that a *pending* order had already committed part of a position before it
+settled — `holdings` had `quantity` and `avg_price` only, no equivalent of the
+`available_balance`/`invested_balance` split already used for cash.
+**Bug fixed**
+`server/trade.go`'s sell path checked `held < qty` directly against
+`holdings.quantity`. This happened to be safe against concurrent double-sells
+only because the whole operation — order, holding check, holding update,
+balance update, ledger, trade — runs inside one transaction with a
+`SELECT ... FOR UPDATE` lock. It was not safe against the actual scenario
+described: nothing distinguished "owned" from "owned, but already promised to
+this order," which matters the moment an order can legitimately sit `open`
+across more than one transaction — exactly what a limit-order matcher would
+need, and what `orders.status` already implied was coming.
+**What changed**
+. `holdings.reserved_quantity numeric(20,4) NOT NULL DEFAULT 0 CHECK
+   (reserved_quantity >= 0 AND reserved_quantity <= quantity)` added to
+   `schema_creation.sql`.
+. `v_portfolio` gained `reserved_quantity` and derived `available_quantity`.
+. `trade.go`'s sell path now: locks the holding, computes
+   `available := quantity - reserved_quantity`, rejects if `available < qty`
+   (previously: rejects if `quantity < qty`), reserves
+   (`reserved_quantity += qty`), then settles (`quantity -= qty;
+   reserved_quantity -= qty`) — two statements instead of one, kept inside the
+   same transaction rather than split into two commits, which would risk an
+   order stuck `open` with reserved crypto and no cancel command to free it.
+. Both `PlaceOrder` branches now insert the order as `status='open'` and
+   `UPDATE ... SET status='executed', executed_at=now()` at the end, instead
+   of inserting `'executed'` directly — `Orders.status` is now a real
+   lifecycle rather than a label written once.
+. `portfolio.go` gained `Reserved`/`Available` columns, reading
+   `v_portfolio.reserved_quantity`/`available_quantity`, so the new field is
+   something a Trader can actually see.
+. The error message on the sell path changed from
+   `"Insufficient holding: trying to sell X, hold Y"` to
+   `"Insufficient holding: trying to sell X, available Y (of Z held, W
+   reserved)"`, since "how much you hold" is no longer the only number that
+   matters.
+**Test evidence**
+Verified against PostgreSQL 16 (`bp_database`, `localhost:5433`):
+. The holding upsert was a read-modify-write in Go. It is now a single
+   `INSERT … ON CONFLICT (user_id, crypto_id) DO UPDATE`, so PostgreSQL recomputes the average
+   in `numeric` arithmetic, relying on the unique constraint of the relational design.
+. `TerraER3.11.jar` was removed from the repository and `.gitignore` now excludes `*.jar`,
+   because P4 requires third-party executables to be downloaded, not committed. `.env` is
+   excluded too, and `.env.example` was added in its place.
+. `image.png`, a TradingView screenshot, was deleted, because the project has no licence to
+   publish it.
+**Verification.** All seven use cases were run against PostgreSQL 16, and the four failure
+paths were tested. After a rejected purchase, the affected user had zero rows in `orders`,
+`transactions` and `holdings`.
+---
+### Session 3 — 2026-09-16 (Claude Sonnet 5)
+**Prompt (student, verbatim):**
+> Soo we have a problem here In this scenario we have an edge case where our functionallity doesn't work:
+> Suppose the user owns:
+>
+> 2 BTC
+>
+> and wants to sell:
+>
+> 0.5 BTC at market price
+>
+> A sensible procedure is:
+>
+> 1. User creates an Order
+>
+> Orders gets something like:
+>
+> id    user    market    side    type    quantity    status
+> O1    Alice    BTC/USD    sell    market    0.5    open
+>
+> At this point, no trade has necessarily happened yet.
+>
+> 2. Reserve the crypto
+>
+> This is where your current model has a gap.
+>
+> You currently have:
+>
+> Holds
+> quantity
+> avg_price
+>
+> but you don't have a concept of reserved/committed crypto.
+>
+> For cash, you already explicitly distinguish:
+>
+> available_balance
+> invested_balance
+>
+> For crypto, you probably want the equivalent:
+>
+> quantity
+> reserved_quantity
+> avg_price
+>
+> So Alice might go from:
+>
+> quantity = 2.0 BTC
+> reserved_quantity = 0
+>
+> to:
+>
+> quantity = 2.0 BTC
+> reserved_quantity = 0.5 BTC
+>
+> with:
+>
+> available BTC = quantity - reserved_quantity = 1.5 BTC
+>
+> The important point is that you generally don't actually remove the 0.5 BTC from her position yet. You reserve it so she cannot submit another sell order for the same BTC.
+>
+> Can you please start from Phase 1 and modify everything to make it work like it should, modify the AIUsage.md in every Phase, and can you make the ConceptualMOdel a little bit more put together not that much spread out.
+The other prompts of that day were about the P1 diagram (logged on
+[ERModelAIUsage](../P1-ConceptualModel/ERModelAIUsage.md)) and about P5 and P6. None of them
+changed the P4 prototype.
+**Response (AI, summarised)**
+The gap: `trade.go`'s sell path checked `held < qty` directly against `holdings.quantity`.
+Nothing distinguished "owned" from "owned, but already promised to an order". This was safe only
+because the whole sell runs in one transaction with a `SELECT … FOR UPDATE` lock. It would stop
+being safe the moment an order could stay `open` across transactions.
+What changed:
+. `holdings.reserved_quantity numeric(20,4) NOT NULL DEFAULT 0 CHECK (reserved_quantity >= 0 AND reserved_quantity <= quantity)`
+   was added to `schema_creation.sql`.
+. `v_portfolio` gained `reserved_quantity` and the derived `available_quantity`.
+. The sell path in `trade.go` now locks the holding, computes
+   `available := quantity - reserved_quantity`, rejects the order if `available < qty`,
+   reserves (`reserved_quantity += qty`), then settles (`quantity -= qty; reserved_quantity -= qty`).
+   All of this stays inside the same transaction.
+. Both branches of `PlaceOrder` insert the order as `status='open'` and set
+   `status='executed', executed_at=now()` at the end.
+. `portfolio.go` shows new `Reserved` and `Available` columns.
+. The sell error message became
+   `"Insufficient holding: trying to sell X, available Y (of Z held, W reserved)"`.
+**Test evidence** (PostgreSQL 16, `bp_database`, `localhost:5433`):
 ```
 …
 ```
+Full transcripts are on
+[UseCase0005Implementation](UseCase0005Implementation.md). The rejected-order
+rollback guarantee from session 2 was re-checked too: after both the
+insufficient-funds and insufficient-holding failure paths, the affected user
+still has zero new rows in `orders`.
+**What I decided:** to keep reserve and settle inside a single transaction —
+splitting them into two, so an order genuinely sits `open` and reserved
+between two commits, is what a real limit-order matcher will eventually need,
+but building that now would add a way for an order to get stuck without also
+building a way to cancel it, which is out of scope for this review. `go build
+./...` was run after every change; all seven use cases were re-exercised
+manually.
+(At that time the sell path still asked for a symbol, so a user with no holding could reach the
+check. Since session 4, such a user is never offered anything to sell.)
+**What I decided:** to keep reserve and settle inside a single transaction. Splitting them into
+two commits, so that an order really sits `open` and reserved in between, is what a real
+limit-order matcher will need. Building it now would add a way for an order to get stuck without
+a way to cancel it.
+---
+### Session 4 — 2026-09-24 (Claude Opus 5.5, 1M context)
+**Prompt (student, verbatim):**
+> Does the P4 documentation, fullfill this:
+>
+> *[pasted: the complete official text "Instructions on Phase P4: First Application Prototype"
+> from the course site — the prototype requirements, the rule that the user must never have to
+> remember identifiers or codes, the PrototypeImplementation / UseCaseXXXXImplementation /
+> BuildInstructions templates, the source-code rules and the AI Use rules with the
+> PrototypeImplementationAIUsage template]*
+>
+> is this correct?
+> Or do we need to change anything?
+**Response (AI, summarised):** an audit of the prototype and of the P4 pages against each
+requirement. The main findings:
+- The prototype asked the user to type a market symbol (`Market symbol (e.g. BTC):`) and, in the
+  watchlist, a crypto symbol. That breaks the rule that every choice must be picked from a list.
+- The use-case implementation pages had one screenshot per use case, not one per step, and did
+  not show the SQL at every step.
+- `PrototypeImplementation.md` was written in Trac markup inside a Markdown file. It did not
+  follow the template, and it said identifiers were never typed, which was not accurate.
+- `BuildInstructions` had wrong details: the `-init` message, the order of the history, an
+  outdated ER diagram path, an unpinned PostgreSQL version described as 16, and a concurrency
+  test with no steps to prepare it.
+- This page listed only one model, still had "Student action required" notes, and had no
+  line-by-line log.
+**Prompt (student, verbatim):**
+> YEs you can start fixing it, and can you make the screenshots yourself?
+**Response (AI, summarised):**
+- **Code** (`market.go`, `trade.go`, `watchlist.go`):
+  - `ListMarkets` now returns the numbered list it prints. `ChooseMarket` asks for `Market #:`
+    and takes the market by its position in that list.
+  - New `ChooseHolding` for the sell path. It lists only the user's holdings that still have a
+    free quantity, with `Held` and `Free to sell`, and asks for `Holding #:`.
+  - Watchlist *Add* lists, numbered, the cryptos not yet on the watchlist. *Remove* lists the ones
+    on it.
+  - A shared `pickNumber` refuses anything outside `1…n` with
+    `Invalid choice, enter a number from 1 to N.`
+  - The SQL that looked a crypto up by symbol (`WHERE upper(c.symbol) = upper($1)`) is gone. The
+    chosen row's id is used directly.
+- **Screenshots:** all of them were retaken from real CLI sessions, driven in a pseudo-terminal
+  against freshly initialised sample data. There is one screenshot per scenario step, including
+  the alternate flows (invalid e-mail, duplicate user, wrong password, invalid amount,
+  insufficient funds, insufficient holding, invalid list choice). This gave 30 screenshots,
+  which replace the old 8.
+- **Documentation:**
+  - Rewrote the seven UseCase000XImplementation pages, with the SQL of each step quoted literally
+    from the code.
+  - Rewrote [PrototypeImplementation](PrototypeImplementation.md) (real Markdown, template
+    order, accurate description of the choices), [BuildInstructions](BuildInstructions.md) (the
+    corrections above, a mini-guide of every menu item, and a smoke test re-run on 2026-09-24)
+    and this page.
+  - Made small matching edits to the P3 use cases UC0004, UC0005 and UC0007, so that the "system
+    lists …, user picks …" steps match the prototype.
+  - Wrote the wiki versions of the P4 pages for the faculty site.
+**What I decided:** to accept the numbered-list change, because it is what the P4 rule asks for.
+I also decided to have the screenshots made from real runs instead of editing the old ones.

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset ef1c1c7 for docs/P4-Prototype/PrototypeImplementationAIUsage.md

Legend:

docs/P4-Prototype/PrototypeImplementationAIUsage.md

Download in other formats: