36 Commits

Include renames

Author	SHA1	Message	Date
JesseMarkowitzandClaude Opus 5	ef25b0a876	Stop re-reading the whole prompt every turn, and let a lost run carry on ... M01, the hundred-turn campaign, is the one REQUIRED test still outstanding. Everything here is about it finishing, and being worth believing when it does. No requirement changed, no acceptance test was retired or relaxed, and M11 §P.1's "no performance requirement" still stands: what changed is the cost of a turn, not what a turn contains. An inference server caches a prompt by its prefix. The history window gave up its oldest action every turn, which changed the prompt near the front and threw that cache away, so nearly the whole prompt was reprocessed every turn however little had actually changed. The window now snaps the oldest depth to a block and holds it, stepping every few turns. Measured on real builder output at an 8,192-token budget: 124.0s per turn against 362.4s. The cost is history depth, bounded by TRIM_FRACTION at a quarter of the window, which is the dial between recent history and speed. A run that dies no longer starts again from turn one. m11_long_run checkpoints resume.json after the prologue, after every scheduled step and after every turn, and --resume reattaches to the same campaign. A finished run deletes it, so the file's presence means an unfinished run and starting fresh over one is refused. The model timeout is an option rather than a hard-coded 600s, a turn that overruns is a failed turn instead of an unhandled exception that ends the run with no summary, and a run that has stopped producing turns writes its evidence and stops. Two checks could not fail. M04's planted clue went into an add_fact "detail" key that the event does not define, so it was dropped and fact_still_in_state could never be true; it is now in "value" and proved at turn one, which stops a run measuring nothing for hours. m11_browser degraded silently without a narrator into two failures that read exactly like a product regression, and now requires one, with --no-narrator as an explicit opt-out that marks the run partial. Window discovery speaks Ollama's native API, so against vLLM or llama.cpp's own server the window goes unverified and the budget uncapped -- M11's own failure mode reached by another route. context_window_override lets the operator state what they launched the server with, and is used only where discovery left a hole: a verified window always wins, so a declaration can lower an unknown ceiling into existence and never raise a known one. "verified" still means the server answered, so window_verified in a turn's provenance keeps the meaning M11's report counts on. planning/README.md said the M11 tree was staged rather than committed, in two places; it was committed and signed. Planning package v3.8. Backend 1,376 passed, 17 skipped, 0 failed; frontend 161; lint and build clean. Every M11 harness re-run on this tree: browser 38/0/0, offline 23/0, identity clean, contrast unchanged, recovery 14/0 on a small bundle. M01 itself has not been run. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01E9LiyxBxnMTXV2wRjdyDGB	2026-09-10 06:13:55 -04:00
JesseMarkowitzandClaude Opus 5	144406cd48	M11: what the server will actually read ... The release-validation milestone, and the thing it had to settle first was whether any of the earlier evidence meant what it said. M8 measured a deployment enforcing a 4,096-token input window while the application budgeted 16,384. Every request returned 200. What Ollama does with the excess is drop the oldest tokens, and the oldest tokens here are the system block — the narrator's rules and the campaign canon. A hundred-turn certification against that server would have looked perfect and proved nothing, which is why this milestone could not begin with a hundred turns. So the application asks now. Ollama's window is a property of how a model was loaded rather than of the request — sending num_ctx is accepted, ignored, and worse, reloads the model at the server's own default — so the only honest move is to find out and then tell the truth about it. /api/ps reports what a resident model is being served with, /api/show what an unloaded one will load with, both on the same host inference already uses, through the same endpoint policy and the same TLS trust store. A verified window is a ceiling on the budget; an unverified one leaves the budget alone and is recorded as unverified in the turn's own provenance, so an old turn can be asked afterwards whether it was built against a checked window. There is no third behaviour, and in particular no hard-coded 4,096: a number the server did not say would be right on one machine and wrong on the next. The proof that this is doing something is a campaign whose canon sits at the front of the prompt, 120 turns of history, and a 4,096-token window. The canon is still there afterwards and the oldest history is gone. The same campaign built the old way produces a prompt more than twice the window — the defect, reproduced, so the fix is measured against it rather than asserted. Two defects the validation found on its own, and they are the same defect twice: something was true and nobody was told. A manual state correction of four changes with one bad reference applied three, returned 201, and said nothing — while recording the refusal on the audit row nobody reads. It came to light because the identity diagnostic's own fixture was refused that way and the whole run proceeded on a campaign with no scene, which would have read as a model failure. And the narration-length setting moved no number: brief, medium and long each became one English sentence, while the numeric hint the model actually reads was derived from the global reply cap and said the same thing for all three. Both now say what they did. The other two post-M8 findings are closed as well. The tab said AI D&D, which no document had ever claimed it did not; it says Interactive Story now, with the open campaign first, and the name is the owner's decision rather than a find-and-replace to something narrower than the engine. After an Undo the reader could not tell where they had landed; the control row now ends with "Moment 11 · later story ahead", from the server's own answer, in the word the transcript already uses, with none of head, branch or depth anywhere near it. The identity diagnostic exists and the root cause does not. That campaign was destroyed, so no cause can be established — what M11 owes the finding is something that can classify the next occurrence, and a diagnostic that makes only the judgements a program can honestly make: duplicate keys, shared names, protagonist drift, state and context disagreeing. Whether prose misattributed a line is left to a person reading it beside its prompt, because a regex cannot read dialogue and one that pretended to would produce exactly the confident wrong answer this finding is about. Its detectors are proved to fire against a planted second Alice. Two entities may still share a display name. That was checked first, as the finding asked, and left permitted: a mother and a daughter, or a stranger giving a false name, are ordinary fiction, and refusing them to guard against a model mistake would refuse the wrong thing. What was missing was that it happened silently. It is reported now. Evidence, not inference: a hundred accepted turns against a real narrator with genuine process restarts; a real browser against the built SPA; a container with no network at all; a campaign moved into a data directory that never existed. Each was discarded and re-run whenever the product changed under it, and the runs that were thrown away are listed in the report with the reason, along with ten defects in the harnesses themselves — because a harness that has only ever agreed with itself is not evidence, and two of M8's five harness defects were masking real ones. No dependency was added, removed or upgraded. No acceptance test was retired, relaxed or reclassified. M11 is implemented and verified; it is not accepted, and there is no release tag. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Qyn3oRd4D6pi72nKBG725B	2026-09-07 14:01:20 -04:00
JesseMarkowitzandClaude Opus 5	44edece67e	M9: a campaign you can actually get back ... A campaign could already be exported and imported. What could not survive the trip was everything that explains it: the state events behind the authoritative document, the prompt each turn was actually given, the passages it was shown, the summaries that carry long-story continuity, and which take belonged to which turn. An imported campaign could be read and could no longer say why it was what it was — and a manual correction, the one state change no narration explains, was indistinguishable from something the story had established. The bundle is now `ai-dnd-adventure-v3`, and the version is the design rather than a side effect. Everything added here could have been another optional key, the way persona, Save Points, narrative state and imported knowledge each were. That mechanism stops working at exactly this addition: a v2 file with no prompt provenance is ambiguous between "written before M9" and "written by M9 from a campaign that has none", and those are different facts about a campaign. A version number is how a recovery file states what it was capable of recording. v1 and v2 still import, and every seam from pre-active-head onward is tested for the rule that an older file is never reinterpreted under a newer assumption. Two categories became three. "Chosen travels, derived is recomputed" was enough until stored prompts had to be decided: they are derived, and they must travel anyway. The test that separates evidence from cache is not "could this be recomputed" but "would a recomputation answer the same question" — a rebuilt search index answers the same question, a rebuilt prompt says what the turn would be told *now*, which is the opposite of what the inspector is for. Also here: a real SQLite backup, through the online backup API rather than a file copy, taken while the application is running and verified before it is kept; story cards settled as compatibility-only legacy data and taken out of the narrator's prompt, because they were the untracked path around knowledge authority that IMPORTED-KNOWLEDGE-DESIGN §73 already forbade; and no schema change at all, proved against a database M8's own code wrote. Three defects, found by running the milestone's own tests rather than by reading them. Deleting a campaign leaked its FTS index rows, and SQLite then handed the freed ids to the next source imported into any campaign, which failed with an integrity error that Reindex could not repair — both ends are closed, and a database already carrying the damage now repairs itself. An imported node with no state snapshot was being stamped with the campaign's head state, so an Undo to turn 2 showed what the story knew at turn 20. And the snapshot relink did not persist at all, because it mutated a dict in place on a column SQLAlchemy tracks by assignment: it looked correct in memory and wrote the wrong ids to disk. Carrying per-turn prompts looked like it would halve the length of campaign that can be restored. Measured — and after compressing them inside the file — everything M9 added costs 12% of it: the import ceiling moves from about 318 turns to about 279, against a 100-turn certification target. The dominant cost is not M9's at all. The per-position narrative state document is 74% of a bundle, and v2 already carried it. Backend 1,102 passed / 14 skipped / 0 failed. Frontend 145 passed. Lint, production build and Docker build clean. Verified across two server processes with two data directories, and in a real browser against a real narrator. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01Qyn3oRd4D6pi72nKBG725B	2026-09-07 01:55:45 -04:00
JesseMarkowitzandClaude Opus 5	1ce9972760	M8: the browser becomes the storyteller ... The interface was AI-DnD's with this product's features bolted into it. The navigation read Home · Adventures · Scenarios · Settings · AI Chat; starting a story meant first picking a *world*, and making a world meant a JSON stat-schema form, a story-card table and an art picker. The play screen had a Branches tab. The input had three modes. Sixteen of the sixteen controls on a two-turn story had no accessible name — they were single glyphs with a tooltip. All of that was measured in a real browser before anything was changed, and the measurements are in planning/reports/M8-IMPLEMENTATION-REPORT.md §C. Almost nothing underneath was wrong: the play loop, the history controls, the takes, the Save Points, the state correction and the knowledge library all worked. What was wrong was what a reader was asked to understand in order to use them. So the shape now is one entry point and one screen: Campaigns -> Campaign -> Story State · Knowledge · Context · Save Points · Settings Everything that is not the story lives in a panel that starts closed. The top navigation bar is hidden on the story screen entirely, because on that one screen the story is the interface. Play is one natural-language field. An action and a piece of quoted dialogue are both just what the reader wrote, and B01/B02 confirmed against a real narrator that the model reads the quotes without being told which kind of turn it is. What survives from the old Story mode is a Story direction toggle, which is not a fourth mode: it changes who is being spoken to, not what kind of action is taken, and the box is visibly marked while it is on. Branch, fork, node, merge and head appear nowhere a reader can see them. The branch panel and the tree overlay are gone from the browser. The mechanism is untouched — takes, divergence, retained futures and Save Points all still work, and their endpoints are still tested. This is a decision about what a reader is asked to understand, not a reduction of what the product can do. The two defects worth the space: A player action is stored with AI Dungeon's "> You " prefix. That was right when the Do mode asked for a bare verb phrase. With one field the spec tells the reader to write "I enter the tavern", and the result was "> You I enter the tavern." — in the transcript, in the replayed history, and therefore in the narration, where a small model imitates it and writes "You I thank her". M8's own design surfaced it, so M8 fixed it: the prefix is added only when the reader has not already written a subject. The ">" marker, which is what actually identifies a player turn in the prompt, is unchanged in every case. And a stale `.input-bar { display: flex }` in play.css overrode the new composer, because that sheet is imported after the new one. The direction row and the input row laid out side by side and the box was unusably narrow. Found by opening the product in a browser, not by reading the CSS — which is the argument for having done that first. Failures now have the taxonomy the spec asked for rather than one toast: model, generation, state, knowledge, server, each with the thing to do about it. A failed turn leaves the reader's words in the box and says so. The classification reads backend strings, so it is a fallback ladder rather than a lookup — an unrecognised message still classifies, still shows the server's own words and still offers Retry. `Settings.model` could be empty with nothing saying so until the first turn failed with a provider error. The header now reports Ollama in five states, and an unconfigured or missing model offers the models actually installed on the endpoint, from the connection test that already knew them. Nothing is chosen automatically: an endpoint's first model may be an embedding model, which cannot narrate at all. Narrator prose is rendered as safe Markdown — headings, emphasis, lists, blockquotes, code. The safety is structural rather than filtered: every node is a React element built from parsed text, and there is no dangerouslySetInnerHTML in the file. A sanitizer is not needed to make markup safe if markup is never produced from input. Link schemes are checked with the URL parser rather than a pattern, because the bypasses are all in the parsing. A remote image is a placeholder naming the blocked address; the knowledge and context panels deliberately do not use this renderer at all, because they exist to show a reader exactly what is in their file. Backend, and only what the browser could not otherwise reach: AdventureCreate.opening a start action could only come from a Scenario, so every campaign made in the new setup flow opened on a blank page. Same node, same code path. canon_rules campaign_canon has been the highest authority in a campaign since M5, read by the prompt builder and the state validator, and had no API at all — a fixture had to write it with SQL. a 401 and a 429 message the last user-facing text describing a hosted deployment. One told the reader to check an API key that has not existed since M2. No schema change and no migration: proved by building a database with a server running the M7 commit's own code and opening it with this one. The project had no frontend tests. It has 132 now, across ten files, running in about six seconds — the enabled state of every history control, the take selector, the confirmations, the panels, the five model states, the failure taxonomy, the focus trap, accessibility, and that the reserved dictation control never touches the microphone. Writing them found a real defect: the focus trap filtered candidates with offsetParent, which is null inside the fixed-position ancestor the dialog has and which jsdom never computes — it would have behaved differently in the tests from the browser. They do not replace the real-browser runs, and both kinds of evidence are in the report. The browser suites drive the production build served by the real backend with a real local narrator, including a genuine process restart. A verification pass over all of it then found three more, each by driving the product rather than reading it: Stepping between alternate takes did nothing. The pager asked whether a take lived on another line by comparing `target.branch_id !== action.branch_id`, and `ActionOut` has never carried `branch_id` — so the comparison was permanently `number !== undefined`, always true, and every step took the branch-switch path. For two takes of an ordinary retry, which share a line until one is written below, that meant switching to the line already being read: the same window came back and nothing moved. D07 is a required v1 acceptance test. The fix needed no new field — the variants list already carries every attempt's branch and marks the live one. The first regression test for that passed against the broken code, because its fixture gave the action a `branch_id` the real payload never sends. That is the exact failure M7's review was about, so the fixture was corrected, the tests were re-run against the reverted code and failed for the right reason, and the fixture now carries a docstring saying why the field must never come back. And the knowledge panel pointed readers at an "embedding model" while the setting is called "Model for meaning-based search" — a reader sent looking for a field that does not exist by that name. Campaign canon was measured rather than assumed. Editing it after play is a configuration change: every turn already played keeps the canon it was actually given, in its own context snapshot, and the accepted story, the state document and the state audit log are byte-identical across an edit. It is not routed through M5's state audit, because canon is not narrative state and doing so would create the second representation the spec forbids. What the editor does now is say so, once a campaign has moments. `BROWSER-UX-SPEC.md` §38 asked for a "Show Hidden Story State" toggle. There is no hidden story state — a secret lives in a narrator-only knowledge source and never enters the state document. The section is rewritten to require what it actually meant: ordinary surfaces must not carry narrator-only information, advanced inspection must withhold it by default behind an explicit warned choice, and no second store may be invented to give a toggle something to reveal. The protection is stricter than before, not weaker. Closeout. An independent review returned M8 IMPLEMENTATION: PASS subject to evidence and documentation cleanup, and this commit carries that cleanup: The report named two frontend bundles as the artifact behind its acceptance evidence. The saved run logs settle it. index-Ii-lARp9.js, built at 18:53:02 from this tree, is the one final frozen artifact behind all 157 browser checks; index-C6E5Uvtu.js is superseded — it predates the D09 fix and its acceptance suite ended 54/55 on exactly that defect. No tracked file under backend/app or frontend/src has a modification time after the freeze, so the whole final campaign describes one build. §P sets the two side by side. Finding 14 — the app budgets 16,384 prompt tokens while an Ollama that sees no VRAM enforces 4,096 — is resolved operationally, with no application change. The OpenAI-compatible endpoint this app speaks accepts num_ctx and ignores it, and reloads the model at its own default, so a native call cannot prime it either. A model derived with POST /api/create carries the parameter, is honoured through the app's own OpenAI-compatible path, and appears in /v1/models — which is the listing the Settings model picker already reads. Measured end to end. The procedure is in DEVELOPMENT.md; nothing in the repository depends on any particular derived model existing. Adding provider code to work around this was declined deliberately: it would mean either a second native request path, against ADR 011, or a parameter the endpoint provably ignores. The §38 rewrite is ratified as a requirement clarification aligned with the implemented architecture, and the spec gains the clause finding 3 was really about: withheld material must be absent from the rendered DOM, not merely collapsed in it. The report's §U carries the M9 handoff — what a portable campaign has to include, whether historical context snapshots belong in the bundle, what happens to inherited story cards, and that a restored campaign may meet a different context window than the one that wrote it. None of it is implemented here. Final: backend 950 passed / 14 skipped; frontend 132 passed; lint, production build and Docker build clean; 157 browser checks across six suites, zero failures. M8 is implemented, verified, reviewed and accepted (2026-09-06). M9 has not been started. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017HdaXiFbscatQaLS7dJk6b	2026-09-06 23:31:45 -04:00
JesseMarkowitzandClaude Opus 5	480414efe0	M7: a first-class imported knowledge library ... A campaign can import local .txt and .md files as Canon, Reference or Inspiration, and the class is load-bearing rather than a label: it decides the words a passage is framed with in the prompt, the weight it carries when passages are ranked, and which budget it competes in when the context is tight. This is a separate subsystem, which is the Phase 0B decision (IMPORTED-KNOWLEDGE-DESIGN.md §73). Story Cards do not carry classification, provenance, content identity, chunking, an index or a lifecycle, and they were not promoted into something that does. Nothing here reads or writes one. The subsystem, in backend/app/knowledge/: classes the three classes, their weights, and the prompt framing chunking deterministic, heading-aware, 60-800 tokens, no overlap fts SQLite FTS5 with porter stemming; scoped and bounded in SQL importer validate, hash, store, chunk, index — in one transaction embeddings local Ollama vectors through the shared provider retrieval query construction, hybrid merge, rerank inject the budgeted cut and the rendered prompt sections Relevance admission is a separate stage from ranking, and that separation is the milestone's most expensive lesson. An independent review found the first implementation deciding relevance with a floor expressed as a share of the best candidate — which the best clears by construction — so a passage was admitted on every turn regardless of the scene. A query about tide tables and container tonnage retrieved all five sources of a fantasy campaign, narrator-only hidden Canon among them. So the pipeline is now: candidate generation -> admission -> ranking -> class weighting -> budget Admission reads raw, candidate-set-independent signals: the cosine the model returned, and how many distinct meaningful query terms a passage contains. Ranking reads normalized ones, because bm25 has no fixed range and cosine's zero is not zero. Normalization decides order among things that matched; it can never decide whether anything matched. Authority is applied after admission, so a class orders what matched and never rescues what did not. Retrieval may therefore return nothing, and on a scene unrelated to the library it does. The other decisions that each replaced an obvious wrong one: - The class multiplies relevance rather than adding to it. An additive bonus satisfies "Canon outranks Reference" and makes "do not include irrelevant Canon" impossible, because a large enough constant wins on its own. - The semantic floor is measured, not guessed: 113 production-path pairs against nomic-embed-text put targeted matches at 0.55-0.85 and off-topic pairs at 0.36-0.56, and 0.58 sits between them. Because it is a property of that model and not of cosine similarity, it is keyed to the model rather than applied to whatever is configured: an embedding model with no measured calibration in this build does not borrow the number. Semantic admission is skipped, the campaign retrieves lexically, and the reason is stated in the knowledge status and in the turn's provenance. Degrading to lexical keeps the library usable; lending the threshold to an unmeasured model is how the admitted-everything defect would return. - One lexical term is not evidence. Two distinct meaningful terms, or one that is neither a standing campaign entity nor a negligible share of the query. The stop list grew from 42 words to 261, all function words — no subject matter, because a stop list that removes subject matter stops finding "The Silver Key". - Lexical retrieval is a production path, not a fallback. It finds the proper nouns and invented terms a setting bible is made of, and the library is fully usable with no embedding model configured. Safety is structural rather than filtered. Imported text reaches the prompt whole, inside a section that says what it is, under a rule stating the authority order in words and refusing every instruction inside it. No endpoint accepts a filesystem path, so H08 has no mechanism to escape from. Nothing renders imported content as HTML, so a script tag is five visible characters and a remote image is never fetched. Import, chunking, indexing, retrieval and a turn open no socket at all; only embeddings do, through the endpoint allowlist the memory bank already uses. Provenance is the rendered text, not a foreign key: deleting a source cannot turn a historical turn's evidence into dangling ids. Schema: knowledge_sources, knowledge_chunks, knowledge_embeddings, and an FTS5 virtual table attached to knowledge_chunks as a DDL hook so it is created and dropped with the table it indexes. Migration 92. A pre-M7 database opens unchanged and needs no sources to play. Bundle: the source content and the reader's judgements about it travel; the passages, index rows and vectors are rebuilt on import, so a restored campaign is searchable immediately without a reindex step. One runtime dependency: python-multipart, Starlette's multipart parser. It is what makes the upload surface possible, and the upload surface is why no pathname is ever accepted. The test doubles were the reason the defect shipped, so they were corrected too. The retrieval stub scored unrelated text at 0.06-0.20 where the real model scores it at 0.43-0.44, and its docstring said it had deliberately removed the constant component that "would put a similarity floor under every pair" — which is exactly the property real models have. The stub now has that floor, one test fails if it is ever removed, and another reproduces the superseded rule and asserts it is still fooled by the same fixture. Run against the pre-corrective implementation, the new suite fails 13 of 18. Tests: 939 passed, 14 skipped (836/7 at M6). 110 new across seven files, one of which mocks nothing between itself and Ollama and re-measures the similarity separation on every run. 43/43 checks in a real Firefox, reproduced. Docker build clean. Four other defects found by review or by the browser run were fixed here rather than carried: an unreachable relevance constant that appeared to enforce something and did not; acceptance tests using the wrong fixture files, so G07's trap was never exercised; a bidirectional override surviving into displayed filenames; and, from the implementation pass, the Insights panel showing M5's two state sections as raw keys and the source inspector refetching on every keystroke. M7 was independently reviewed, which returned PASS WITH CORRECTIVE WORK REQUIRED. Both blocking findings are closed, and closeout resolved the embedding-model calibration boundary the corrective pass had left as debt. planning/reports/M7-IMPLEMENTATION-REPORT.md carries the review, the corrective closeout and the closeout verification in sequence, none overwriting another. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017HdaXiFbscatQaLS7dJk6b	2026-09-06 15:40:13 -04:00
JesseMarkowitzandClaude Opus 5	b7005e6fdd	M5: genre-neutral authoritative narrative state, with review corrections ... Replaces AI-DnD's RPG relative-delta world state with the genre-neutral typed narrative state of ADR 010: explicit, absolute, allowlisted events proposed by the model, validated by the application, applied to one authoritative document, and snapshotted per position so restore stays a row read. This commit includes the corrective pass that followed the independent review in planning/reports/M5-IMPLEMENTATION-REPORT.md. The invariant it exists to hold is: visible active transcript position == stored head == authoritative state Narrator editing (D10, STORY-BRANCH-SEMANTICS §§14-15) A narrator edit no longer rewrites a row. It returns to the state before the turn, takes the reader's exact text as the accepted narration, re-derives the state that text implies, and becomes a new active continuation — while the original narration keeps its words, its live flag and its whole future as retained history. At the tip the correction is another take; with story below it, it forks. No new history machinery: this is the existing fork/take/head path with the reader's text in place of a generated reply. The §14A refusal is therefore gone for narrator turns, and remains only for player input. Pre-M5 positions Migration 88 backfills the empty narrative document onto every action written before M5, and a missing snapshot now restores the empty document instead of leaving the previous position's state standing. Restoring to an old Save Point no longer leaves a later position's entities and facts on screen. Narrator context Replayed history carries prose only; the machine-readable block is no longer reconstructed into past turns, where it contradicted the authoritative state in the same prompt. A fact withdrawn by a manual correction is now named as no longer true, with the reader's reason, rather than silently dropped. Also - state_changes joins the action-list bulk read, removing one query per row. - Extraction takes only the application's own protocol payload: an ordinary ```json or ```python block in a story survives, and a mangled proposal still does not reach the reader. Planning: ADR 013 records the authoritative document shape; §§14-15/14A, D10, C04 and BUILD-MILESTONES are updated to describe what exists. Debt is recorded against M8 (scenario editor UX) and M9 (export of the audit trail). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PWU4gTfLYY6Qq9U7aa9Qw2	2026-09-05 07:01:50 -04:00
JesseMarkowitzandClaude Opus 5	62a997f364	M4: close out Save Points, with browser verification ... Closes M4. The review's three findings are fixed, the durability rule the specification always implied is now enforced, and M3's and M4's browser behaviour has been verified in a real browser for the first time. B-1 -- the Save Point list was an N+1 that loaded whole Action rows, narration included, to answer "does a row exist here". It is now one bulk two-column coordinate query plus one lineage: 53 SELECTs for 25 Save Points became 5, and the count no longer grows with the list. The clause is an OR of exact (branch, depth) pairs rather than two IN lists, because the cross product would report a Save Point resolved on the strength of another one's depth existing on this one's branch. A test builds exactly that trap. B-2 -- reclassified during closeout from "missing warning" to a behaviour defect, and fixed as one. STORY-BRANCH-SEMANTICS §19 says a named checkpoint remains until explicitly deleted, and §28 already required future cleanup to retain checkpoint-referenced paths; a cascade that silently removed Save Points with a branch violated both, and a warning would only have documented the violation. A branch a Save Point names can no longer be deleted. The request is refused with the offending Save Points named, the user deletes them explicitly -- which deletes no story -- and the branch then goes. The scope is the subtree, because deleting a branch takes its descendants. Both delete controls disable and explain. Recorded as a new §19.1; models.py, TECHNICAL-DESIGN §8.8 and DATA-MODEL §8 had all recorded the cascade as the rule and now record the refusal. An earlier pass in this same closeout had kept the cascade and added a warning. That was the wrong fix and its tests were replaced rather than left standing, since they pinned the defect. B-3 -- the D11/L03 automation never left one process, so it could not distinguish durable state from a live Python object. It now spawns real server processes, kills the first, and reads the campaign back with the second. C-5 -- creating a Save Point takes the campaign's turn lock. "Save where I am" has to name one committed position, and the head is what a turn in flight is about to move. Rename and Delete deliberately do not take it. The architecture is untouched: a Save Point is still name + note + (branch, depth), and restore is still coordinate -> head.move_to_node -> head.move_to -> attempts.restore_state. No second restore path, no state copied into a checkpoint, no fork on restore. Browser verification -- the first in this project, and it covers both milestones. Firefox 154.0.1 through geckodriver over the W3C WebDriver protocol, driving the rendered DOM: 47/47 checks, twice, on independent databases, no console errors. M3's Undo/Redo enable states, transcript movement, Retry and the take pager, divergence retiring Redo; M4's whole Save Point lifecycle, both confirmations, and the new branch-delete refusal including its recovery. No dependency was added: the WebDriver client is stdlib HTTP. No application defect was found by the browser. Four failures occurred, all in the harness -- a wrong SPA route, a wait comparing transcript length when the empty-story placeholder is longer than the first turn, a fixture deleting the branch it was reading, and a reload assertion that sampled once instead of waiting. The last was checked against the app before being called a harness bug. Tests: 698 backend pass (was 680), 60 M4, 94 M3 history, 66 export/ migrations, 93 security/local-only. Frontend lint and build clean, Docker build clean, loopback binding unchanged. No assertion weakened, no skip added. Planning: STORY-BRANCH-SEMANTICS §19.1 is the only behavioural change and it strengthens §19. V1-ACCEPTANCE-TESTS records D11-D14, I04, L03 and the E-series, keeping automated, live-runtime and browser evidence distinct, and weakens no pass condition. DATA-MODEL records the coordinate with the retry measurement that settles it. BROWSER-UX-SPEC rules for Moment over Turn. BUILD-MILESTONES marks M4 COMPLETE, closes M3's browser condition, and lists what M5 inherits. VERSION adds v2.6. No new ADR: ADR 005 already decides that history is preserved rather than overwritten, and §19.1 is that decision applied to checkpoint-referenced history. M4 is closed. M5 may now be briefed; it has not been started. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PWU4gTfLYY6Qq9U7aa9Qw2	2026-09-04 06:34:56 -04:00
JesseMarkowitzandClaude Opus 5	e08d49c3eb	M4: add durable named Save Points ... A Save Point is a name for a story position, and restoring one is head movement. That is the whole architecture, and it is what ADR 012 and BUILD-MILESTONES' note on M4 asked for: M3 made the head a stored (branch, depth) and made arriving at one a row lookup plus a state restore, so a Save Point needs no restore machinery of its own. What the user gets: - Name the moment they are reading, keep playing, restart the app, and come back to it. Restoring moves the story back and deletes nothing: the later turns stay, Redo still walks forward into them, and writing something different is what starts a new line while the old one is kept. - Rename, delete, and a list, in a Save Points panel beside the branch panel, with a Save Point button next to Undo and Redo. Both confirmations say what is *not* destroyed, because that is the part the screen cannot show. - Save Points survive export and import. What was deliberately not built: - No second restore path. `head.move_to_node` is the only new movement: its depth half is M3's `head.move_to` unchanged, and its branch half is the single assignment `switch_branch` already makes. No head field is written in the checkpoint router, nothing reconstructs state, nothing prunes a memory, nothing copies or deletes a turn, and restore never forks — the first write below the restored head does, through `fork_if_behind_head`. - No automatic cleanup. A Save Point behind the head, or naming a line the story left, is doing its job (STORY-BRANCH-SEMANTICS §19). The one removal is a cascade: deleting a branch takes its Save Points, as it takes its memories, because the story they named went with it. - No new ADR. ADR 012 already decides the architecture, and a table is not a decision. The one call the planning package did not already make: restore moves the branch half of the head only when the coordinate is off the path being read. Doing it unconditionally would quietly hand back an abandoned continuation whenever a Save Point in a shared prefix was restored; never doing it would make a Save Point on a departed line unrestorable, which contradicts §19. TECHNICAL-DESIGN §8.8 records it. Schema: a `checkpoints` table holding a name, an optional note and a (branch, depth) coordinate — no copy of any story. `create_all` builds it as it did `memories` and `branches`; migration 80 adds the index. No backfill, because nobody had named a position before M4. The coordinate is deliberately not an action id: one coordinate holds every attempt at a turn and exactly one is live, so a coordinate follows a retry where a row id would pin a take the story no longer tells. Tests: 680 pass (638 before). 42 new in tests/test_save_points.py covering D11-D14, I04, L03, E-series lineage and memory isolation after restore and divergence, the edge cases, and an M3-database migration. One pre-existing fixture in test_tree_migration.py needed `checkpoints` added to its drop list — SQLite refuses to drop a table another table references. Not verified: the browser. No session has had a usable one, so the Save Point panel's DOM behaviour is unobserved — as M3's Redo control still is. The twenty-step sequence was driven over HTTP against a live server with a real process restart instead, and all seventeen checks pass. M4 is implemented, not accepted: no review has been written. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PWU4gTfLYY6Qq9U7aa9Qw2	2026-09-03 18:48:54 -04:00
JesseMarkowitzandClaude Opus 5	903fa7a74f	M3: move the story's head instead of deleting its turns ... Undo deleted. It removed the trailing AI action and the player action in front of it, pruned the memories covering them, and let the tip fall back to whatever survived. That made it the one operation in the application that destroyed accepted story, and it was why there was no Redo: the turns to move forward into no longer existed. Phase 0B demonstrated the head-cursor alternative in a disposable spike; this is that concept as production code. backend/app/head.py is the whole of it. Three questions that used to be one — where the story is being read, how far it is retained, and where it opens — are now three functions, and every caller that moves the head or asks about it goes through this module. The spike put the fork check in the write path and left Retry and Add-take on the old one; sharing the rules is what stops that divergence coming back. lineage.Path now caps every entry at the head, so hiding the retained future costs nothing at the call sites: the transcript, the context builder, attempts.preceding and memory retrieval already funnelled through path_of and narrow together. Path.uncapped() is the deliberate exception, and only Redo and the fork check may use it. The memory bank needs no pruning for the same reason — a memory carries the coordinate of the node its block ends on, so one derived past the head falls outside the capped clause and becomes retrievable again on Redo without having been deleted and re-embedded. Undo alone does not fork. Moving the head is not a decision to abandon anything, since the user may be reading or about to Redo; the first write below the head is where the story states which continuation it means. A head already at the tip forks nothing, so a story that is never undone forks exactly as often as it did before and the branch table does not fill up with one branch per turn. Redo follows the lineage rather than choosing among branches, which is what invalidates it after a divergence with no flag to set or clear. Migrations 78 and 79 give a branch superseded_at and superseded_depth. Nothing reads them to decide behaviour — Redo is decided by the lineage, so a stale or hand-edited value here cannot make the story wrong. They exist so the cleanup and discarded-history features left to a later version have something to select on, and so a divergence is observable in a test. Deleting an action no longer drags a moved-back head forward to the recomputed tip, which would have silently redone the story. can_undo and can_redo ride on AdventureOut and ActionPage because the client can work out neither for itself: the campaign opening may be off the top of the loaded window, and the retained future is never sent to it. This is a checkpoint, not the finished milestone. 601 backend tests pass. Five still assert the destructive contract — they count rows after an undo and expect the story to be shorter — and need rewriting against the new one; the world-state assertions inside them already pass. Export and import do not yet carry the head coordinate, so a bundle still reopens at the deepest node and can silently redo an undone story, which is the Phase 0B finding this milestone exists to close. The browser has no Redo control yet. None of the M3 acceptance coverage (D01-D10, E01-E04, I01-I03, I07, L01-L02) is written. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QF5TcoB86QADgjHz1GZe8u	2026-09-03 11:45:01 -04:00
JesseMarkowitz	8c65ae99de	M2: cut the hosted product away from the local one ... 94 files, +1,395 -6,578. Three files are new; twenty-four are gone. The milestone is subtraction, and what is left is the single-user local storyteller the specification describes. Removed in full: campaign scripting and its QuickJS sandbox; multi-user accounts, guest sessions, login, registration and the shared demo key; the visitor-analytics tables, dashboard and page beacon; the access log of sign-ins, addresses and devices; per-IP and per-user rate limiting and quotas; Render deployment config; Postgres and psycopg; cloud inference providers, the API-key field and the key encryption that existed to store it; session-cookie signing. None of it was hidden behind a flag — the routes are gone and answer 404. Two things were kept that the brief allowed keeping. The `users` table and its foreign keys stay as an internal ownership detail, because rewriting them out means a migration across most of the schema to delete a column that costs nothing; nothing creates a second user and no request carries an identity. Five inert tables and four inert columns stay for the same reason, so an M1 campaign database opens unchanged. The one addition is app/endpoints.py, which decides where a story may be sent. Loopback, RFC1918, link-local, unique-local and CGNAT — an explicit allowlist of networks, not a guess at what `ipaddress` means by "private", which calls the documentation ranges private and IPv6 loopback reserved. Every address a hostname resolves to must be in it, so a split answer does not squeak through, and the rule runs both when the endpoint is saved and before every outbound request, because a name that resolved to the LAN this morning can resolve elsewhere this afternoon. Known cloud hosts are named in the refusal so the error says why rather than looking like broken DNS. TLS is never traded against it: M1's shared trust context is intact on all four clients and there is no way to skip verification. The hardcoded 120-second model timeout is now a setting. That was not theoretical — on this GPU-less four-core host a cold load of qwen2.5:3b-instruct took 648.9 seconds to produce the first turn, while turns 2 to 5 of the same campaign took 3.6 to 13.1. Connect stays short at 10s so a wrong address still fails fast; the read timeout defaults to 300s and is bounded at 3600, because "wait longer" must stay a number. Two defects found while testing and fixed here. An unknown /api path fell through the SPA catch-all and came back as HTML with status 200, so a client asking for JSON parsed a web page instead of learning the route was gone. And AIDND_CORS_ORIGINS accepted "*", which on an unauthenticated loopback API would hand every page on the Internet a write handle on the campaign database; it now refuses to start. Verified rather than assumed. Offline, on a network with no route out and no DNS: five turns, retry with both takes retained, restart with an identical transcript digest, a failed model call leaving the accepted AI-turn count untouched, and a capture with zero non-loopback unicast packets. Against a real second machine on the LAN over HTTPS with a private CA: four turns, restart, and a capture showing 289 packets to the approved host, 344 loopback, zero anywhere else, zero DNS queries. Cloud and public endpoints refused with their reasons; no API key settable; every removed route 404. 604 backend tests pass, down from 648 by the fifteen retired with the subsystems they tested and up by the twenty-nine added for the endpoint policy and the removed surface. The scripting tests were not deleted: eight files used a JavaScript counter as instrumentation for the state snapshot and rollback machinery, which M2 does not touch, so the counter moved to the world-state engine and those tests still assert what they always did. Frontend lint and build are clean; the image builds, and its wheel-building stage is gone with quickjs. No M3 work. Undo is still destructive and there is still no Redo.	2026-09-02 11:27:14 -04:00
Claude	9ee052c51e	Give the adventure a persona, so the protagonist has a name ... The player had stats but no identity. `stat_schema.player` carried hp and mana beside `npc.gwen.trust`, but where an NPC has a name and a description the player had neither, so the block rendered as `You: hp 100/100` and nothing in the prompt said who "you" was. Three columns on `adventures`: name, pronouns, description. All user-only, all optional, and an empty name means the app behaves exactly as it did before — no backfill, no special case for an adventure that predates the migration. They are adventure columns rather than part of `stat_schema` for two reasons. An adventure with no RPG layer still has a protagonist, and that is the case this was added for. And `worldstate.schema._initials` treats every dict inside a stat section as a stat definition, so a persona placed there would be instantiated, rendered in the guide, and handed an `initial` value as though it were one. The paths do not change. `player.hp` stays `player.hp`; only the label moves, to `Kaelen (player): hp 100/100`, the same way NPC lines already print a display name beside the id. A path carrying the persona's name would break the moment a player renamed their character, because `_history_text` replays every past turn's stored delta into the prompt and those blobs hold literal `player.hp` strings. The section sits in the system block. Only the user can edit it, so it never changes mid-story and stays inside the cached prefix. That is what makes it free, and it is why the AI must not be able to move it — a delta aimed at `persona.*` is already refused by `_resolve`, and there is now a test holding that in place. The modal that used to appear only for scenarios with `${Placeholder}` tokens now always opens, and is where the character is named. Persona and placeholders stay independent: a scenario asking for `${Name}` is asking its own question. No scenario in the repo uses placeholders at all, so the overlap is hypothetical. Phase 2, which feeds the persona and the cast to the summarizer, is written up in plan/18 and not started. That is where the memory-quality problem actually gets fixed; this change is what gives it a name to use. Not yet driven in a browser — plan/18 lists what to check by hand. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01NPyQN926gkZTAYfgugcaok	2026-08-31 15:03:20 +05:30
parththakkar106andClaude Opus 5	f1bebe18d0	Drop the eight legacy columns SP8 left behind ... Migrations 66 to 73 drop `actions.index`, `variants`, `variant_index`, `variant_count`, `state_before`, and `world_state_before`, plus `adventures.memory_cursor` and `summary_cursor`. `index` is a keyword in SQLite, so migration 71 quotes it. Nothing outside the migrations read these. `models.py`, `schemas.py`, and `ACTION_LIST_COLUMNS` lose the same eight fields, `Adventure.actions` orders by `id`, and `attempts.renumber`, `context.history.max_action_index`, and `nodes.next_index` are deleted. Two changes keep the migration replayable on a `create_all` database: - `_split_variants_into_siblings` wrote through the live ORM table, so it stopped compiling once migration 66 removed five of its columns. It now writes through `_ACTIONS_AT_60`, a frozen `Table` with its own `MetaData`. - Five data passes read columns these migrations drop. Each now calls `_has_columns` and returns early when the columns are absent. `bootstrap` takes a `through` version so a migration test can stop at the schema it asserts on. 555 tests pass, up from 549. Eight of the new cases assert each column is gone after a real schema-45 database migrates all the way. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_0198qDK3gmgSo7EtQ4GTPqqK	2026-08-29 17:15:49 +05:30
parththakkar106andClaude Opus 5	e0bf2b61d9	Add a useDebouncedSave hook and delete Settings.stream ... Two items from Stage 2 of `plan/17-refactor.md`. `frontend/src/hooks/useDebouncedSave.js` replaces three copies of the same debounce. `PlotPanel` and `ScenarioEditor` held identical per-key timer maps. `ScriptEditor` held a single shared timer, so editing two fields inside the same 600 ms window canceled the first save. The hook gives every key its own timer, which fixes that. `Settings.stream` was dead state. Nothing read it and every turn streams. This removes the column, both schema fields, and adds migration 65 to drop it. It is item S1 in `docs/self-review.md`. Migration 65 needs a new guard. `_column_already_gone` is the counterpart to `_column_already_there`: `create_all` builds the current schema, which is already missing every dropped column, so a fixture that stamps an old version and replays would fail on a column that is not there. Verified: 549 backend tests pass, lint and build are clean, and migration 65 runs both ways, once against a database that still has the column and once against one that does not. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014Dix4oGV3njgWRdu7P9t6r	2026-08-29 02:12:32 +05:30
Parth	e7d75c3b05	Rewrite Python comments in Google developer documentation style (#12) ... * Rewrite comments in Google developer documentation style Rewrite the comments and docstrings across the backend core modules so they read plainly. The previous prose was accurate but dense and figurative, which made it slow to skim. Applies the Google developer documentation style guide: short sentences, active voice, present tense, American spelling, and no metaphors, idioms, or rhetorical asides. Replaces em-dash chains with separate sentences.	2026-08-26 15:37:25 +05:30
parththakkar106andClaude Opus 5	f9b836fc0b	Put the pager back, and let any turn be played again ... SP7 replaced the pager with chips, on the grounds that a chip could also offer "take this path" while a pager could only step. Driving it by hand said otherwise, and the reason is worth keeping: the chip meant two different things depending on where the reader was standing -- a real switch at the tip, a preview needing a second button above it further back. Two meanings in one control is what made the tree unusable. So: one control that does one thing. Stepping reads a take and nothing else, and it tells the server nothing, because reading is not a decision. The transcript below a take that is not live simply ends -- such a take is a leaf by construction, since whatever was played after the turn was played after the take that *is* live. The decision is made by writing, and `after_id` carries it. One step does reach the server and is still not a fork: a take with a story of its own lives on its own branch, so going there is a branch switch and only the server can say what is underneath. `branch_id` on the take is what tells the two apart without asking first. And a fork button on every turn but the opening. On the AI's it regenerates; on your own it opens the text so you can say something else. What the story made of the old take is kept, on the line it was written on. `selectVariant` and `forkFromAttempt` leave the client. Both endpoints stay -- tested, and `stand_on` is shared with the write path -- but the pager needs neither. 426 backend tests; lint and build clean. Not yet driven by hand: the frontend still has no test runner, so this needs the `--keep` fixture and eyes, exactly as SP7 did. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 21:34:12 +05:30
parththakkar106andClaude Opus 5	ea7336e5d3	Let any turn be played again, not just the newest ... `retry` only ever saw the last action: mid-story there was no way to ask for another take at all. Now the take endpoint takes either kind of node, and the kind decides what happens -- an AI turn regenerates, a player turn takes the text supplied. The client asks the same way for both. The tip is the only case that needs no branch, and only for an AI turn, where the takes are still leaves nobody has built on. That is the existing retry, reached by another road. Everywhere else `branch_at` leaves the path just before the turn so the story after it keeps the take it was written for. Both paths roll the shared state back to before the turn ran, which the fork endpoint was already doing and the player-take path was not -- a script would otherwise have stacked this take's output mutations on the one being replaced. 426 tests. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 21:34:12 +05:30
parththakkar106andClaude Opus 5	c3c9b310eb	Put the pager's numbers on the page ... `2/4` needs the shape of a turn's take group for every message on screen. Asking `attempts.group` per row would put a query behind each one -- the exact cost `variant_count` was cached to avoid, and the reason SP8 could not just drop that column and be done. So one query per page, keyed on the parents the page mentions, and the count and ordinal land on the rows before they are serialised. `take_count` / `take_index` rather than reusing the old pair, because they do not mean the same thing: the old ones cache a coordinate's siblings and say 0 for a turn nobody retook, these count the *turn's* takes across whatever branches they ended up on and say 1/1. SP8 still drops `variant_count` and `variant_index`. Two traps, one of them mine. `parent_id` was not in ACTION_LIST_COLUMNS, so reading it off a windowed row would have been a lazy load per action -- an N+1 hidden behind the thing `load_only` exists to prevent. And the adventure GET does not build `ActionOut` at all: it hands the window to the relationship with `set_committed_value` and lets Pydantic walk it, so patching the three places that do build ActionOut missed the one path every page load takes. The test caught it by reading the wire instead of the helper. 424 tests. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 21:34:12 +05:30
parththakkar106andClaude Opus 5	2726840c60	Let a player's own turn be played again ... Retry has always given an AI turn another take. Nothing gave one to the message the player wrote, so the only way to change something you had typed was to overwrite it -- destructively, losing whatever the story made of it. That is the half of the tree the player asked for first, and it never existed: `POST /actions/{id}/fork` answers 400 unless a second take is already there, so "branch from here" was not a thing the API could do. `tree.branch_at` is the missing piece. `fork` moves a node that already exists onto a line of its own; this is the same branch with nothing in it yet, for a take that has not been written. The head lands one depth short, so the next node written is the new take -- same depth, same parent, resolved from the path by `place_action` without being told. The line being left keeps its node, keeps it live, and keeps everything played after it. Nothing is copied. Two things the tests said rather than confirmed. A player turn is never the tip: the reply to it is, so retaking even the newest thing typed still owes a branch, and the guard against forking for nothing only fires for a player action with no reply under it. And player text is stored formatted, so a test that compares it whole is testing the formatter. 421 tests. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 21:34:12 +05:30
parththakkar106andClaude Opus 5	e126bda387	Make the branch happen when you write, not when you look ... Stepping between takes used to be two controls and two meanings. At the tip a chip switched; above the tip it only *previewed*, and taking that line needed a second button next to it. Which one you got depended on where you were standing, which is the thing that made the tree unusable when it was driven by hand. So the server stops caring that anyone is looking. Reading a take the story moved past changes nothing and creates nothing. `ActionCreate.after_id` names the node a turn is played after, and naming a take the story left is the first moment the player has said which line they mean -- so that is where the fork happens, and only there. `stand_on` is the old fork endpoint's body, lifted out whole. It already knew the two cases and got them right: at the tip the takes are leaves nobody built on, so it is a switch and no branch is made; past the tip the line being left keeps every turn it has, so the take needs a branch. Both callers now share it, which is the point -- a fork asked for and a fork arrived at are the same move. Six tests. Five fail with the grouping reverted to the coordinate, and the one that does not is deliberate: naming the tip in `after_id` must stay an ordinary turn that forks nothing, which guards against over-correcting rather than against the original bug. The nesting test passes both ways too and is kept for what it says, not for what it catches -- a coordinate separates C1's takes from C2's by accident, because the fork has already put them on different branches. 415 tests. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 21:34:12 +05:30
parththakkar106andClaude Opus 5	2d38a162d4	Give every memory a node, and show only the ones on your path ... A hand-written memory used to carry a NULL depth, described in the model as "belongs to the adventure rather than to a path". That sounds harmless and is not: a NULL is a coordinate no fork can cap, so a note typed on one line followed the reader onto branches whose story it never described. It takes the head now — the story you were reading when you wrote it — and obeys exactly the rule a summarised memory obeys. The unanchored escape clause in lineage.Path.clause existed for that single case and is deleted rather than left unused. Its docstring argued that a capped depth would drop a typed memory the moment its branch stopped being the newest entry; anchoring answers the same worry better, because the memory is not exempt from the path, it is on one. The drawer now shows the path being read and nothing else, filtered by the clause retrieval itself uses, so the bank you can see is the bank the model can see. Nothing is stranded: a memory lives on a branch, switching to that branch shows it, and deleting the branch deletes it. Pinning decides order, the path decides existence. Migration 62 lands existing NULL-depth memories at depth 0 of their branch rather than at the tip. 0 is at or before every fork point, so every memory stays visible from exactly the paths it is visible from today — nobody's bank loses a row on deploy. The tip is the tidier-sounding choice and would have emptied them out of every branch forked earlier than they were typed. This supersedes the on_path flag and the "another branch" badge from earlier today; anchoring makes them redundant, and they are removed. Four tests changed because they asserted the old contract, not because they broke. The one worth reading is the pair replacing test_a_hand_written_memory_is_not_lost_at_the_first_fork: typed on shared trunk it still survives a fork, and typed on ground the fork never travelled it no longer follows you. 402 tests. Verified on tools/branch_fixture.py: each branch's drawer holds its own memory and not the other's. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015H5qiyiR7gtFQaoDphHZ3g	2026-08-18 19:14:07 +05:30
parththakkar106andClaude Opus 5	1d1367ce3a	Say which memories the model can actually see ... Retrieval has been path-scoped since SP3: a memory on a branch this story never travelled is never sent to the AI. The drawer listed every memory alike, so on a fork you read "Fell down the cellar stairs; badly hurt" and reasonably concluded the model knew it. It does not. That is worse than either hiding the row or retrieving it — it is the screen claiming something the engine contradicts. Hiding them is not the answer either; that was the original comment's point, and it stands. A memory nobody can list is a memory nobody can delete, in a phase whose rule is that nothing is removed automatically. So the whole bank still lists, and the rows off the current path are set back, dashed, and labelled "another branch". MemoryOut.on_path carries it, computed from the predicate retrieval itself uses rather than a second spelling of the same idea — two spellings drift, and the failure mode here is a badge that says the opposite of what the model gets. Pinning does not override it: the path clause runs before pinning is considered. The relationship is asymmetric and there is now a test that says so. A fork borrows its ancestors, so a memory written on the parent is on the fork's path too; the reverse never is. Worth pinning before somebody makes it symmetric on the grounds that it looks wrong. 399 tests, three new, egress ceilings intact — the flag costs one id-only query. Verified in a browser on tools/branch_fixture.py. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015H5qiyiR7gtFQaoDphHZ3g	2026-08-18 19:14:07 +05:30
parththakkar106andClaude Opus 5	84827f0f37	Put the tree on the screen ... The pager could only step between attempts, and stepping has nothing to say about the thing the tree exists for: taking a path the story moved past and keeping both. Every attempt has been its own node since SP4, so a chip is a node now, and "take this path" forks — or simply switches, when the turn is still the tip and its attempts are leaves nobody has built on. Beside it, a Branches panel: every line the story has taken, with where each left its parent and where it ends, and switch, rename and delete-with-confirm. It sits with Plot/Memory/Scripts/Insights rather than inventing a new place to put a rail. An unnamed branch is drawn from its fork depth, never from its position in the list — a position shifts the moment a branch above it goes. A spatial per-node map was considered and deliberately not built. At the size this has to be verified against it is a second windowing problem, and it can be added later without a new endpoint, since the rail and a map read the same GET /branches. VariantOut grows an id because a fork is addressed by the node being taken, not by an ordinal in a group that renumbers. Driven by hand against the 602-action fixture, which found one bug that no test could: the panel refreshed on actions.length, and a fork swaps a 60-action window for another 60-action window, so it went on drawing a one-branch tree while the story was already on the second. It keys off the counter adoptWindow bumps now. The scroll path was driven at the same time — three prepends of ~16,200 px, the same node holding viewport top 792 to 787, never thrown to the end. That closes the standing gap in this project. Console clean. 396 tests, build clean, no new lint. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015H5qiyiR7gtFQaoDphHZ3g	2026-08-18 19:14:07 +05:30
parththakkar106andClaude Opus 5	cf3d52171e	Let a branch be named, and thrown away ... SP7 needs three branch operations and SP5 built one. Switching exists; naming and deleting had no column and no route between them. A name is stored because a player chose it. An unnamed branch keeps NULL rather than a generated "branch 4" — a generated label is derived, and it would go stale the moment a branch before it is deleted and the ordinals shift underneath. The client draws those from the fork depth, which nothing can shift. The v2 bundle carries the name for the same reason it carries the fork points and leaves `lineage` out: it is a decision, not something computed from one. Delete is what stands between a tree and unbounded growth, since nothing prunes one on its own. It refuses two branches: the root, which holds the turns every other branch borrows, and the one being read — including any branch the head was forked from, which is the same mistake in disguise and the one that would cascade the head away and leave head_branch_id pointing at nothing. The nodes, memories and descendants go through the foreign keys that already cascade. A cursor standing on a deleted branch is cleared. On Postgres a stale branch id would simply never resolve; SQLite hands the freed id to the next fork, and then the anchor resolves onto a branch it has never seen and calls a stretch of story already summarized. 396 tests, 15 new. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_015H5qiyiR7gtFQaoDphHZ3g	2026-08-18 19:14:07 +05:30
parththakkar106andClaude Opus 5	ffb2fd5b0e	Let a story go two ways at once ... Attempts pile up at the tip as leaves and cost nothing. The moment the player takes the story down one the line has already moved past, the two futures have to coexist — so `tree.fork` gives that attempt a branch of its own, forked at the depth just before it, and the line it leaves keeps every turn it has. One row is inserted and one row is moved. Nothing is copied: everything before the fork is borrowed through the lineage cached on the branch row. Measured on a 40-turn story forked twenty times — 21 branches, 140 rows, an 80-action story — the page load costs 31,652 B against the 31,433 B the same story flat costs, and a branch is 103 B of ancestry. Nothing derived moves either, and that is the part worth keeping: a memory hangs off the coordinate the parent's attempt still occupies, and the lineage caps the parent one depth short of it. The fork simply cannot see it, so it resummarizes that ground from the text it actually tells, without a line of bookkeeping. Two things had to change underneath. A new node's depth now comes from the tip of its branch rather than from the adventure-wide `index`, which would have left a hole in a fork's path the width of the other branch. And undo stops at the fork — the turns before it belong to the branch this one grew out of. `GET /branches`, `POST /branches/{id}/switch` and `POST /actions/{id}/fork` are the endpoints SP7's tree view is drawn on. 365 tests green, 18 of them new in test_branch_forking.py. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-18 19:14:07 +05:30
parththakkar106andClaude Opus 5	cf8ec22e8b	Open an adventure on a window of the story, and page upward ... Opening a finished adventure fetched every action in one response: 589.5 kB on production's longest, and nothing about that curve bends on its own, because a story only ever gets longer. The page load now brings the newest 60 actions and the reader pages up from there. On the harness's 600-action fixture that is 606.0 kB down to 62.6 kB, and -- the part that matters -- it no longer depends on how long the story is. Paged by anchor, not by offset. `before_id` is the oldest action the caller holds; the server returns what precedes it. An offset counted back from the newest would shift every older position the moment a turn lands, which is exactly when someone is likely to be scrolling, and the reader would get one action twice and never see another. It also keeps working when the story stops being a flat list: comparing indices to order a branch survives the story tree, treating them as positions does not. `has_more` comes from fetching one row past the window rather than from counting. A deleted anchor -- undo, mid-scroll -- reports the end rather than guessing and serving a page the reader already has. GET /{id}/actions and POST /{id}/undo now return {actions, total, has_more} instead of a bare list. Undo is the action most likely to be repeated several times running, so having it re-fetch the whole story would have undone the paging on the worst case. The adventure payload gets its window through set_committed_value rather than by assignment: the actions relationship cascades delete-orphan, so assigning a 60-item list to it would delete everything outside the window on the next flush. In Play.jsx the prepend is followed by a useLayoutEffect that restores the scroll position, before paint, so the story does not jump. Loading starts 400px from the top rather than at it, guarded by a ref because scroll fires far faster than React re-renders. There is a button as well as the scroll trigger: on a short viewport the transcript may not be tall enough to scroll at all, and a reader who cannot scroll must still be able to reach the beginning. Verified against a running backend and a 220-action adventure: the page load returns 60 of 220 ending on the newest, and walking back from an anchor returns exactly the actions before it. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017Dvvqn9ZDR4ixeFPHNbww7	2026-08-17 14:23:03 +05:30
parththakkar106andClaude Opus 5	906ba423d8	Keep every retried attempt instead of deleting it ... Retry used to delete the last AI action and generate a replacement, so the discarded narration was simply gone. The row survives now: each attempt is appended to actions.variants with variant_index naming the live one, and a ChatGPT-style pager under the message browses them. Action.text still mirrors the active variant, so the context builder, memory bank, summarizer and export needed no changes. A variant carries only what differs between attempts -- the text, the reasoning, and the state it produced -- never the assembled prompt, which is identical across attempts of one turn and is the bulk of context_snapshot. Only the last message can be switched, restoring the script/world state that attempt produced; earlier turns were written as a continuation of whatever is active there, so theirs are read-only previews. Three things that would otherwise bite: - generate_turn now wraps _generate_turn and watches for a save sentinel. If the generator ends without it (provider error, empty reply, script stop, client hangup) it re-applies the previous variant -- otherwise a failed retry leaves rolled-back stats under un-rolled-back text. - Retry reuses the turn's own index rather than next_index, or the clock the world-state cooldowns run on advances on a re-run of the same turn. - Editing a message rewrites the active variant too, or paging away and back silently reverts the edit. Migrations 34/35 verified as an upgrade against a populated database, not just a fresh schema. test_state_revert's retry test asserted the old delete behaviour and was rewritten. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UeQVy5bEjLhfgWNc27Efet	2026-08-02 20:44:06 +05:30
parththakkar106andClaude Opus 5	d66fd1d6a2	Add a reasoning-off setting (-1 reasoning budget) ... Models like DeepSeek V4 Flash reason by default, and the reasoning budget setting could only ever add thinking tokens - there was no value that turned thinking off. A negative budget now sends `reasoning: {effort: "none"}`. Uses effort:none rather than exclude:true deliberately - exclude still thinks and still bills, it only hides the trace. Zero keeps its old meaning (send no `reasoning` field at all) so endpoints that reject unknown fields, like the default Ollama one, are unaffected. Reusing the existing int column this way avoids a migration. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01UeQVy5bEjLhfgWNc27Efet	2026-08-02 11:10:35 +05:30
parththakkar106andClaude Opus 5	aed28d9295	Add "Update from scenario" to pull scenario edits into a running adventure ... An adventure copies its scenario's plot text and story cards at creation so later authoring never disturbs a story in progress. This is the explicit opt-out, alongside the existing per-script "Sync from library". GET /adventures/{id}/refresh returns a plan (per-field old/new diff, card add/update/remove, world-state added/removed paths, and any ${...} answers still needed); POST applies it under the turn lock so it can't race a generating turn. The Plot panel shows the plan in a confirm modal first. Overwrites the plot fields and scenario-derived cards. Deliberately left alone: the opening `start` action (the story is built on it, and it is baked into memories and the summary), the adventure's own title and summary, player-authored story cards, and the live value of every stat the schema still defines. Two enablers were needed: - adventures.placeholders (migration 32). ${...} answers were used once at creation and discarded, so re-copying scenario text would have re-injected a literal ${Hero}. Adventures predating the column re-prompt once via the existing modal, then the answers are saved. - story_cards.source_ref (migration 33), "card:<id>" / "npc:<key>", NULL for player-authored. Adventure cards had no link back to their source, so a rename read as delete-plus-add and player cards would have been clobbered. Legacy cards name-match once, then adopt the ref. World state goes through a new worldstate.reconcile(): keep values the schema still defines, add missing ones at their initial, drop removed ones and their cooldown bookkeeping. Not instantiate(), which would heal the player to full and wipe their milestones. The confirm modal is portalled to <body>: .side-panel's panel-in animation has fill mode `both`, which makes it the containing block for position:fixed descendants, so an overlay rendered in place was trapped in the 420px panel and clipped by its overflow. 14 new tests in backend/tests/test_scenario_refresh.py; 85 pass. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01XzBCyXH4hBEVHqEaertcq4	2026-08-01 09:51:49 +05:30
parththakkar106andClaude Opus 5	1dd31086c1	Add power-user AI Chat page; centralize demo-key model pinning ... AI Chat is a plain scratchpad for talking to a model directly — no story context, scripts or world state — for poking at models, prompts and endpoints without starting an adventure. Power users only: the router 404s (rather than 403s) for everyone else and the nav link is hidden. The conversation lives in localStorage, so there's no new table or migration. is_power_user() now also returns True in local mode: it's the operator's own machine and their own key, the same reasoning that makes the provider debug log local-only. Alongside that, the rule keeping the shared demo key off paid models now lives in exactly one place. It had been duplicated into the chat router, which is how one copy eventually drifts: - resolve_provider_config() takes an optional model_override and is the only place the whitelist is applied, so turns, AI Chat and the connection test all inherit it. An override is a per-request preference, never a grant. - ProviderConfig.__post_init__ refuses to exist when api_key is the demo key and the model isn't whitelisted. It keys on the key itself rather than the using_demo flag, so a mislabelled config can't slip past, and it raises so a future path that bypasses the resolver fails loudly instead of billing. - The demo branch still pins endpoint_url too — a user-controlled endpoint would leak the key itself, which is worse than spending it. Provider gained chat(messages, ...) beside generate(), both delegating to a shared _stream(url, body); completion-mode endpoints get the messages flattened into a labelled transcript. Settings' /models fetch moved to list_endpoint_models() and is shared with /api/chat/config. Tests: 10 new in tests/test_chat.py (70 total). These deliberately do not stub resolve_provider_config — the point is to exercise the real BYOK-vs-demo decision and assert on what the provider actually received: off-whitelist override pinned, off-whitelist Settings.model pinned, redirected endpoint pinned, BYOK passed through untouched. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014FGY1yvzSeKgTtRfeVtDmx	2026-07-26 20:16:56 +05:30
parththakkar106andClaude Opus 5	57c24a07d8	Redesign the library UI and add scenario cover art ... Rework the home page into a single landing surface and give the app a consistent visual language, chosen as "illuminated tome" over two other pitched directions because it builds on the existing Cinzel + gold identity instead of replacing it. Home is now Continue (up to 4 in-progress stories, each showing where you left off) over a scenario shelf, each section with a "See all" link. The full adventure list moves to /adventures. Scenario cover art has three tiers, in precedence order: an uploaded picture (downscaled client-side to 400px WebP before storing), an emoji, or gradient art generated from a hash of the title so no card is ever an empty box. Adventures inherit their scenario's art. Images live in the row rather than on disk because Render's free tier has no persistent volume, and it keeps export bundles self-contained; list responses carry a cacheable /api/scenarios/{id}/image URL rather than the base64. Also: ambient drifting motes behind the app, loading skeletons, staggered card entrance, ornamental scene breaks and a drop cap in the story, a "Weaving" thinking indicator, and a toast system replacing every alert(). Two fixes found along the way: - Importing a scenario bundle with no "tags" key returned a 500. Column defaults are not applied until flush, so the attribute was still None when the width clamp sliced it. - Anything meaning "the story's latest narration" was missing action type "start", which is the only text a freshly created adventure has, so new adventures looked empty. Collected as NARRATION_TYPES. Migrations 30 and 31 add scenarios.image and scenarios.icon; both are additive with a '' default and were verified against a database stamped at 29. vite.config.js now reads AIDND_API_PORT so the recurring port-8000 clash with another local app needs no file edit. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_014FGY1yvzSeKgTtRfeVtDmx	2026-07-26 13:17:46 +05:30
parththakkar106andClaude Opus 4.8	279110f75b	Show per-turn stat changes under each AI message ... Each AI action now carries a compact world_changes summary (derived from its stored snapshot), rendered as small chips beneath the message: numeric stats show a signed delta (green up / red down), flags show on/off, milestones show a check. Gives an at-a-glance "what changed" without opening Insights. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-21 16:48:35 +05:30
parththakkar106andClaude Opus 4.8	4dac445f90	Add Phase 12: native RPG world state ... Structured world/player/NPC stats, two-way flags, and sticky milestones per scenario (stat_schema). The AI proposes a per-turn delta; a Python engine referees it (clamp to min/max, per-turn cap, cooldown, counters). Band word-labels plus a fixed stat guide (descriptions + full ranges) keep the model grounded. World State drawer + Insights delta report; undo/retry roll it back via the Phase 11 snapshot pattern. - migrations 26-28 (scenarios.stat_schema, adventures.world_state, actions.world_state_before); all nullable, additive, safe on existing rows - migration 29 raises the default context budget 4096 -> 16384 (custom values preserved) - seeded demo scenario 04-rpg-world-state.json (Bandit Camp) - 19 new tests (33 total pass) Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>	2026-07-21 14:47:29 +05:30
parththakkar106andClaude Opus 4.8	328ae8942d	Add per-adventure "Sync from library" for scripts ... Adventure scripts are frozen snapshots taken at creation. Add an opt-in way to pull the latest library code into a live adventure: - AdventureScript.source_script_id links a copy to its library Script (migration 24; set at adventure creation) - list endpoint flags out_of_date by diffing copy vs library - POST /adventures/{id}/scripts/{sid}/sync overwrites the copy's code, preserving enabled/position/script_state - legacy copies with no link fall back to a name match, then adopt the link - Play page shows a Sync button only when a copy differs from its library Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01TEpWMjnfPqzZ13nPMoGhs5	2026-07-21 00:56:01 +05:30
parththakkar106andClaude Opus 4.8	4772171b6c	Phase 9: production hardening ... Config via env, abuse/resource limits, and production serving so the app is safe to expose publicly: - Fail-fast on missing SECRET_KEY when MULTI_USER=true - quickjs per-execution time/memory limits (while(true) can't hang server) - Per-user/per-IP rate limiting on turn/script/auth endpoints - Request body size limit + per-user row caps - Security headers (CSP, X-Frame-Options, nosniff, referrer-policy) incl. SSE - Debug router 403 and /docs disabled in multi-user mode - DATABASE_URL support (defaults to Neon Postgres) alongside SQLite - Documented all env vars in backend/.env.example Verified locally via uvicorn (MULTI_USER=1, SQLite); see plan/09-phase-hardening.md. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017e6tQuojBLYPetUfmhit4X	2026-07-07 12:30:06 +05:30
parththakkar106andClaude Fable 5	de4db373f2	Phase 8: optional accounts, per-user data, shared demo key ... Guest-first multi-user mode behind AIDND_MULTI_USER (local installs unchanged): signed-cookie guest sessions bootstrapped by /api/auth/me, register upgrades the guest in place, login/logout, per-IP rate limits. Every router scoped by user_id; Settings become per-user with the API key Fernet-encrypted at rest and write-only through the API. Users without a key get a server-funded demo key (OpenRouter free models, 20 turns/day, memory bank disabled on demo turns). Public read-only demo scenarios (seed_demo.py); debug log restricted to local mode. Frontend: auth modal + guest nudge, 401 re-establish/retry, demo banner and key management in Settings. Migrations 13-23 adopt existing data under a local user and encrypt stored keys. Verified: migration on a copy of real data.db, two-session isolation + register/login via curl and Chrome, demo cap 429, live OpenRouter turn through the encrypted-key path, vite build + oxlint. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KFsGHju9szibJJa2YJcdbg	2026-07-06 23:04:03 +05:30
parththakkar106andClaude Fable 5	db9f904222	Initial commit: AI Dungeon clone (FastAPI backend + React frontend) ... Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01KFsGHju9szibJJa2YJcdbg	2026-07-06 16:08:19 +05:30