Pythos Changelog

• Implicit Linear Solving Fast-Path: Standalone and question-marked linear expressions (e.g. (3x-6?), (3x-6 = ?), (3x-6)) now resolve deterministically via ALGEBRA_LINEAR_SOLVE, inferring equating to zero and disclosing the zero-RHS assumption in user-visible steps.
• Algebraic Identity vs. Equation Root Disambiguation: Upgraded Pattern 10d in verificationBridge.js to extract equation_solution for scalar candidates against unadorned expressions rather than universal identities ((3x-6 equiv 2)), eliminating false INVALID_CLAIMS_DETECTED withholding.
• Multi-Turn Context Base-Prompt Resolution: Stripped contextual metadata tags from base prompts during claim extraction, allowing model validations in subsequent turns to bind and verify against the root problem.
• Conversational Student Answer Intent Recognition: Enhanced studentIntentClassifier.js and contextManager.js to recognize informal student responses containing conversational adverbs and slang (e.g. "its flipping 2 man ez math", "obviously 2"), classifying them as PROPOSED_ANSWER.

• Trailing Equals & Incomplete Equation Solving: Incomplete equations ending in = (e.g. (3x-9=), (5x-6=)) now automatically infer equating to zero, solving the linear equation and disclosing the zero-RHS assumption in user-visible steps.
• Quadratic Factoring & Binomial Expansion: Added deterministic closed-form factoring for quadratics with common lead factor extraction (e.g. (2x^2+14x+12 = 2(x+1)(x+6))) and FOIL expansion for binomial products (((2x+4)(3+5x))), delivered with complete step derivations.
• Verification Daemon Concurrency Isolation: Completely removed unsafe FIFO fallback in CAS response resolution; daemon responses strictly correlate by unique request ID, eliminating cross-request contamination.
• Calculus Leibniz Whitespace & Real-Domain Conditions: Expanded derivative regex to support spaced Leibniz notation (d/dx ln(x)) and surfaced required real-domain condition ((x > 0)) in delivered responses.
• Exact Candidate Verification & ReDoS Removal: Replaced substring containment checks with exact symbolic equivalence in candidate delivery; hardened multi-turn problem extraction against catastrophic ReDoS backtracking.
• Complex Root CAS Deferral: Defer complex equation roots from Math.js substitution to SymPy CAS with robust string serialization and magnitude residual checking.

• Modular Arithmetic Congruences: Implemented modular congruence verification across Math.js and SymPy pipelines. Congruences of the form (Ax \equiv B \pmod M) and modular inverses now evaluate under modulus (M), verifying exact integer modular solutions without false (mathbb{R}) extraneous root withholding.
• Multiplicand-Preserving Arithmetic Extraction: Hardened intermediate fraction extraction with preceding-factor and continuing-operator boundary guards. Prevents truncating fractions from Euler totient ((phi(n))) and multi-factor arithmetic steps, allowing chained steps like (85 \times \frac{4}{5} = 68) to evaluate cleanly.
• Multivariable Equation Root Isolation: Added variable identity guards preventing scalar quantities (such as radius (oxed{r = 12}) or line distance (oxed{d = 10.2})) from binding as roots for variable (x) in multivariable curves.
• Quadratic Connective Root Extraction: Expanded quadratic root extraction to capture second roots across LaTeX text connectives (\text{ or }, \lor) and comma separation without repeating variable names.
• Symbolic Equivalence Filtering: Sanitized inline math delimiters, added absolute value parsing, and filtered non-fractional polynomial curve equations from false symbolic equivalence claims.

• Scoped Contradiction Detection: Completely refactored auditInternalConsistency in server/verificationBridge.js to isolate variables, equations, and Markdown sections. Independent equations (such as \(x^2 + 1 = 0\) having no real roots alongside \(y - 4 = 0\) having root \(y = 4\)) no longer trigger false-positive contradiction flags, while true intra-equation contradictions remain strictly rejected.
• Domain-Restriction Singularity Isolation: Upgraded _find_denominators in algebra_verifier.py to differentiate real and complex denominator singularities in closed form. Prevents cancelled denominators in auxiliary equations from invalidating solutions for independent target variables, and fails closed (VERIFIED_ON_UNKNOWN_DOMAIN) when singularities cannot be analytically certified.
• Fail-Closed Candidate Delivery Gating: Hardened evaluateCandidateDelivery to require candidate answers to bind strictly to verified target claims. Any response containing unverified answers or invalid intermediate claims (audit.invalidClaims > 0) triggers canonical safe pedagogical withholding (SAFE_WITHHOLDING), eliminating unverified token leakage.
• Upstream Refusal Routing & 4096 Token Ceiling: Intercepts upstream model refusals directly to safe pedagogical guidance and expands the generation token ceiling to 4096 to prevent truncation on extensive multi-step mathematical derivations.

• High-Throughput Calculus Engine: Integrated a native Calculus Engine (server/engines/calculusEngine.js) backed by a persistent SymPy worker daemon. Performs symbolic differentiation, Leibniz notation parsing (d/dx, d/dt), definite/indefinite integration, sinc limits, and extrema optimization in under 10ms with zero process-spawn overhead.
• Specialized Right-Triangle Geometry Engine: Added a dedicated Geometry Engine (server/engines/geometryEngine.js) with exact radical arithmetic, automated Pythagorean validation, and dynamic visualization spec generation directly routed via domainSpecialistRouter.js.
• Multi-Worker Request Correlation: Implemented bidirectional request-response ID tagging (_id) across stdio pipes, guaranteeing complete request isolation and preventing pipe desynchronization under high-concurrency workloads.
• Multi-Tier Verification & Rate-Limit Hardening: Upgraded derivative claim extraction with mathematical operator exclusion to prevent variable collision, qualified circle area extraction to prevent false rejections on circumference/diameter queries, and standardized HTTP 429 UPSTREAM_RATE_LIMITED status responses across all providers.

• Concise Educational Clarity Directive: Introduced a high-signal pedagogical pacing directive into PYTHOS_SYSTEM_PROMPT. Pythos begins directly with mathematical solutions, stripping out theatrical greetings, repetitive fluff, and conversational padding while preserving full step-by-step reasoning and student guidance.
• Measurable Cost & Token Reduction: Benchmarked a 38.1% overall reduction in output tokens across representative problem suites (up to -70.6% on conceptual physics explanations and -37.5% on multi-step kinematics), maintaining 100% deterministic mathematical verification and zero response truncation.

• Deterministic Answer Precision Validation: Integrated automatic precision extraction in problemClassifier.js and proactive verification in studentWorkEvaluator.js. Pythos now identifies when student entries violate homework rounding instructions (e.g. nearest hundredth, decimal places, significant figures) without forgiving calculation errors.
• Context-Aware Geometric Diagrams: Enhanced deterministicRouter.js to extract symbolic sides and expressions from active dialogue context, rendering tailored right triangles with radical and variable annotations.

• Nested Math Delimiter Parsing: Replaced fragile regex passes in app.js with a balanced-brace parser supporting nested radicals, fractions, and boxed solutions without KaTeX duplication.
• Streaming Truncation Detection: Elevated token limits and integrated truncation indicators to detect upstream completion cutoffs honestly with one-click continuation prompts.

• Proactive Academic Milestones & Check-Ins: Integrated exam and quiz detection into memoryExtractor.js and memoryService.js. Pythos now tracks upcoming tests and warmly checks in with students after their exam dates pass.
• Episodic Conversation Search Tool: Added the allowlisted search_conversation_history tool to toolController.js, enabling Pythos to search past saved lessons in Firestore for long-term tutoring continuity.

• Message-Level Thumbs Feedback: Added accessible 👍 / 👎 buttons on all assistant bubbles with integrated clarification reporting.

• Floating Study Hub & FAQ: Added discreet bottom-right collapsible drawer with crawlable curriculum links (Algebra, Calculus, Physics, Simulation Lab) and structured Socratic STEM FAQs, resolving crawler thin-content warnings while keeping the workspace clean.
• Metadata & Schema Optimization: Expanded Title tag to 56 characters, added high-intent keywords across meta tags, embedded JSON-LD FAQPage schema, and added descriptive alt text across language selectors.

• First-Class VerificationStepAudit Telemetry Contract: Transformed mathematical verification from an internal binary pass/fail decision into a structured, step-level data contract emitted across streaming NDJSON and JSON responses. Each derivation step now carries the evaluated expression, the certifying engine (Math.js or SymPy CAS), mathematical domain assumptions ($x \in \mathbb{R}$, positive roots, branch cuts, error tolerance), and the exact verified comparison state.
• Interactive Derivation Proof Receipt: Added a subtle, accessible 🛡️ Verified (N steps) badge on the bottom-right corner of assistant responses matching Report and Copy styling. Students and educators can click it to inspect the real-time CAS proof audit without cluttering the chat flow.
• Targeted Socratic Revision Injection: Enhanced the automated revision loop to inject pinpoint mathematical failure diagnostics (e.g. expected CAS truth vs. candidate discrepancy) directly into revision prompts, eliminating blind retries and maintaining deterministic accuracy.

• Magic-Byte MIME Sniffing: Implemented server-side binary format sniffing across clipboard paste and phone photo uploads, ensuring PNG, WebP, and JPEG images carry accurate Content-Type headers rather than forcing JPEG mime types on upstream vision models.
• Multi-Turn Vision Token Bounding: Automatically bounds conversational history to recent turns on multimodal requests, eliminating upstream rate limit (HTTP 429) spikes on long homework sessions while preserving necessary conversational context.

• Exhaustive 50,000-Problem Campaign: Completed large-scale validation with PRNG stream seed 2236067977 across 12 STEM and hardening domains. Delivered 22,722 verified-correct derivations (45.44% delivery rate), safely withheld 27,278 problems (54.56%), delivered zero incorrect answers (0.00%), and recorded zero verification escapes (0.00%).
• 100% Truth Recovery Under Fault Injection: Under a 10% candidate fault-injection cohort (5,000 deliberate anomalies), the verifier caught 5,000 / 5,000 unverified claims (100% catch rate) and recovered ground truth explanations in 2,920 / 2,920 eligible cases (100.00% recovery correctness).
• High-Efficiency Local Execution: Processed all 50,000 problems in 71.1 seconds with 260 MB peak RSS, running offline with zero cloud tokens consumed.

• Deterministic Triangle Calculation Priority: Prioritized exact numerical derivation for Pythagorean hypotenuse problems prior to visual coordinate rendering, lifting Geometry & Trigonometry domain performance to 4,200 / 4,200 (100.00%) verified correct derivations.
• Mobile Calculator Modal Fix: Resolved viewport initialization bug where mobile devices were trapped inside the floating calculator overlay on initial page load.

• CSS Box-Model Subpixel Reflow Stabilization: Resolved an intrinsic layout hysteresis edge-case where negative free-space allocation in dynamic flexbox layout columns triggered aggressive box-model compression (min-height: 0 resetting under hidden overflow contexts) on late-arriving assistant response buffers during multi-turn sessions.
• Intrinsic Element Size Anchoring: Enforced strict flex-shrink: 0 !important; and min-height: fit-content !important; invariants across specialized assistant response wrappers, guaranteeing complete bounding rect preservation.
• Programmatic Viewport Scroll Vector Interpolation: Re-engineered scrollToMessageTop coordinate resolution using differential bounding matrix projection relative to the active scroll parent viewport, eliminating layout shifts and anchoring viewports seamlessly.
• Container Positioning Normalization: Added explicit position: relative to the primary chat scroll container (#output) to enforce deterministic offset parent resolution across modern browser engines.

• Edge-to-Edge PhET Sim Lab Sheet: Converted the Sim Lab modal on viewports ≤ 768px (tested on Samsung Galaxy S21 Ultra ~384px-412px) to a native 100% full-screen sheet with zero wasted margins.
• Active Lab Navigation 2-Row Reflow: Added responsive flex wrapping so Back, Reset, Ask Pythos, and the simulation title neatly stack in 2 rows without overflowing screen edges.
• Bounded Responsive Canvases: Added strict aspect-ratio and max-width scaling to all 17 simulation models, Function Grapher (#graphCanvas), and Inspector Modals, guaranteeing zero box overflow.
• Floating Tool Window Mobilization: Bounded all tool windows (Grapher, Calculator, Step Verifier, Converter, Matrix, Equation Builder) to calc(100vw - 16px) with touch-scrollable bodies.
• Touch Ergonomics & ARIA Compliance: Upgraded interactive slider thumbs to 24px with full ARIA semantics (aria-label, aria-valuenow, aria-valuetext) and prevented mobile input auto-zoom with 16px font sizing.
• Firebase Session Continuation (Cost Optimization): Pythos now automatically resumes the student's most recent conversation upon login rather than generating a new chat document every time, significantly reducing Firestore write and creation fees while keeping the + New Chat button readily available for fresh sessions.

• Floating Simulation Context Attachment Chip: Queues active instrument state as an interactive chip above the chat input, allowing students to type custom questions with full simulation context rather than forcing pre-baked auto-submissions.
• Multi-Turn Simulation State Retention (server/contextManager.js): Extracted live instrument sliders and calculated readouts directly into activeProblemState.active.knownVariables, preserving simulation context across follow-up turns.
• Inspector Modal Unification: Upgraded Right Triangle Trigonometry, Number Line & Inequalities, Function Grapher, and Statistical Distribution modals to attach interactive context chips instead of firing instant submissions.
• Visual User Message Badges: Messages sent with simulation context render a high-contrast 🔬 <Title>: <Details> badge directly inside the student's chat bubble.

• PhET-Style Classical Sim Lab (vizEngine/simLab.js): Launched a dedicated, interactive simulation laboratory modal accessed via the new [ ⚛️ Sim Lab ] toolbar button. Features a shelf catalog of all 17 interactive STEM instruments, category filter tabs (All, Physics, Chemistry, Math), real-time search, custom high-contrast dark scrollbars, and the "Ask Pythos" 💬 Socratic bridge.
• Simple Harmonic Pendulum (pendulum.js): Interactive pendulum arm with mass bob, release angle, and uniform gravity. Computes real-time period $T = 2\pi\sqrt{L/g}$ with Borda correction, restoring torque, and kinetic/potential energy transformations.
• Geometric Optics & Snell's Law (optics.js): Planar boundary refraction ($n_1\sin\theta_1 = n_2\sin\theta_2$) with media refractive indices (Air, Water, Glass, Diamond), incident and refracted rays, normal line, angle arcs, and automatic Total Internal Reflection (TIR) detection.
• Archimedes' Buoyancy & Upthrust (buoyancy.js): Hydrostatic displacement and buoyant force ($F_b = \rho_f V g$) simulation featuring water tank visualization, waterline display, submerged fraction, density presets, and net force vector equilibrium.
• Hooke's Law & Router Hardening: Added apostrophe-invariant pattern matching in server/deterministicRouter.js, mapped $k, x, m$ aliases in hookes_law.js, and eliminated false-positive triangle error cards in app.js.
• Single-Stage Viewport Architecture: Re-architected shelf and experiment view switching with authoritative display properties, guaranteeing 100% full-screen modal view without window splitting.

• Zero Dead Margin Layout: Reclaimed all unused border margins by converting .app-container and .main-area into a full-bleed edge-to-edge workspace that utilizes 100% of the display window.
• Expanded Simulation Grid: Mathematical and physics instruments now default to wide mode with side-by-side 2D interactive canvases and parameter control panels, eliminating vertical crowding.
• Spacious Reading & Derivation Bounds: Expanded message and welcome cards to allow complex multi-step KaTeX mathematical solutions and starter pill arrays to lay out horizontally without unnecessary wrapping.

• Adaptive 80% Viewport Scaling: Automatically sets CSS zoom to 80% with synchronized 125vh visual height bounding on compact laptop and desktop screens (viewport height ≤ 850px, e.g. 1366×768, 1440×900, and scaled high-DPI laptops).
• Expanded Breathing Room for Instruments: Ensures the Interactive Right Triangle Inspector, 2D Classical Ballistics & Projectile Motion simulator, dynamic parameter sliders, and step-by-step KaTeX mathematical derivations fit completely on screen without vertical clipping.
• Seamless Large Display Fidelity: Full-size desktop monitors (>850px viewable height) and mobile handheld viewports continue to render at native 100% scale without disruption.

• Universal Interactive Visual Inspectors (Graph, Geometry, Number Line, Chart): Audited and unified all inline diagram cards with interactive modal inspectors featuring real-time sliders, exact mathematical property panels, and direct "Ask Pythos" tutoring shortcuts.
• "Always Draw It Out First" STEM Pedagogical Engine: Modeled the foundational rule of trigonometry and physics education. Pythos now proactively mounts interactive geometric right-triangle widgets ([GEOMETRY: triangle ...]) and physics visual models for reference angles, trigonometric function evaluations ($ an 150^circ$, $csc(5pi/4)$, $sec(1050^circ)$), and force setups without forcing the student to explicitly type "draw" or "sketch".
• Expanded Natural-Language & Radian Angle Parsing: Integrated natural-language angle recognition in server/trigExpressionParser.js supporting radian $pi$-fractions ($5pi/4$, $7pi/4$, $-13pi/7$), degree angles, Pearson/MyMathLab question transcriptions, and reference angle queries.
• Zero Conversational Hallucination & Self-Spoiler Guardrail: Hardened server/learnerState.js and server/server.js against conversational hallucinations (forbidding the model from claiming the student calculated or submitted steps they didn't take) and strictly prohibited the model from answering its own pending questions in parenthetical asides.
• Eureka & Gratitude Intent Recognition: Added EUREKA_OR_GRATITUDE intent to server/studentIntentClassifier.js to accurately categorize "aha!" moments and expressions of clarity without misclassifying them as mathematical submissions.
• Practice Problem Generator Exclusions: Prevented reference table, chart, formula, and notes requests from being erroneously hijacked by the practice generator.
• Model Chain-of-Thought & Scratchpad Sanitization: Implemented stripModelScratchpad to eliminate <think> tags and third-person planning prompt bleeds from model responses.
• Mismatched Input Guidance: Added Guided Mode conversational handling for students entering numbers from a different problem (e.g. jumping ahead without pasting the problem), guiding them back to the active problem without dumping the old solution.
• Comprehensive Regression Coverage: Verified full 30-case student intent suite, 22-case learner state suite, 16-case practice generation suite, 17-case nested trig viz suite, and 10-case safe response constructor suite with 100% pass rates.

• Verified-Truth Recovery System: Added an authoritative recovery path for cases where a generated mathematical candidate is rejected but Pythos already possesses independently verified truth from a deterministic router, preflight tool, or trusted mathematical model. Pythos can reconstruct a safe response from that truth instead of unnecessarily withholding it.
• Mandatory Recovery Re-Verification: Recovered responses remain subject to the verification and delivery gates. Recovery never bypasses mathematical verification; it changes the source of the candidate response.
• Fail-Closed Recovery Boundary: When trusted truth is unavailable, ambiguous, or unsupported, Pythos continues to withhold rather than fabricate a result.
• Fail-Closed Division-by-Zero & Domain Protection: Fully hardened execution pipeline against numeric Infinity and NaN leaks on division by zero ($15/0$), negative real square roots ($sqrt{-49}$), non-positive logarithms, degenerate triangles, and inconsistent linear equations ($0x = 7$).
• Expanded Deterministic Geometry & Physics: Added Pythagorean perimeter ($a+b+c$) and area ($rac{1}{2}ab$) solvers, constant-speed velocity ($v = d/t$), and multi-turn active premise correction recognition.
• 50,000-Problem Recovery Stress Validation: A fresh deterministic campaign recovered 2,920 / 2,920 cases with independently verified truth available, with 100% recovery correctness. The campaign delivered 21,733 verified answers, safely withheld 28,267 unsupported cases, and recorded 0 incorrect delivered answers and 0 verification escapes across all 50,000 problems.
• Targeted Regression Coverage: All 10 recovery, safety, fidelity, ambiguity, and master-regression suites passed: 597 / 597 (100%).

The 2,920 / 2,920 result measures the recovery subsystem specifically: when Pythos rejects an invalid candidate and independently verified truth is available, the tested recovery path successfully reconstructed a mathematically correct response in every tested recovery case. It is not a claim that every mathematical problem is solvable or that Pythos is universally accurate.

• Authoritative Safe Response Constructor: Implemented server/safeResponseConstructor.js and updated the Delivery Gate to ensure Pythos never withholds verified mathematical truth when an independently verified solution or preflight tool result exists, even if the conversational LLM candidate explanation fails verification.
• Conditional ASCII Diagram Suppression: Suppressed redundant ASCII right-triangle sketches whenever interactive geometry tokens ([GEOMETRY: ...]) render successfully, preserving ASCII diagrams strictly as an honest fallback when graphical rendering is unavailable.
• Verification Bridge Precision & Negative Degree Handling: Corrected regex boundary scanning ([^ *:=]*) for right-triangle geometric claims and added negative degree unit support ([-+]?[0-9.]+), preventing false Pythagorean rejections and degree-to-radian misinterpretations.
• Composite Trigonometric Step Fidelity: Updated prompt-to-claim fidelity verification to recognize valid intermediate steps in composite trigonometric derivations (such as inner cotangent calculations within outer cosecant problems) without false fidelity mismatches.
• Comprehensive Regression Coverage: Verified 10-case safe response constructor suite (test-safe-response-constructor.js) and 8-case visual fallback suite (test-visual-fallback-conditional.js) alongside full 284-case accessibility and 70-case benchmark suites with 100% pass rates.

• Nested Trigonometric Visualization Engine: Implemented dedicated parser (server/trigExpressionParser.js) to mathematically decompose and evaluate composite nested queries such as csc(cot(-28.45°)), evaluating inner operations prior to outer functions while tracking angular degrees versus dimensionless radian inputs.
• Strict Geometric Grounding: Prevents naïve extraction of angular magnitudes as triangle side lengths (e.g. cot(-28.45°) = 28.45); derives true positive Euclidean triangle side lengths with Pythagorean theorem validation and quadrant IV orientation notes.
• Visual Fidelity & Contradiction Sanitization: Enhanced enforceVisualFidelity to inspect generated visual tokens and prose against verified mathematical models, correcting contradictory claims and replacing inaccurate geometry parameters with verified values.
• Browser Mount Reliability: Automatically unwraps code-fenced visualization tokens so interactive geometric canvases mount immediately in the browser, while stripping orphaned internal pipeline placeholders.
• Comprehensive Verification: Added 17-case nested trig regression suite (test-nested-trig-viz.js) alongside 70-case benchmark and 25-case tool utilization suites with 100% pass rate.

• Controlled Tool Utilization Architecture: Implemented an intent-driven tool request layer allowing Pythos to intentionally invoke specialized backend capabilities (deterministic CAS calculations, right-triangle geometry rendering, function graphing, practice problem generation, student work evaluation) through structured, validated requests.
• Strict Allowlist & Security Boundary: Server-enforced allowlist strictly restricts model tool invocation to 5 authorized capabilities with per-tool argument validation, bounds checking, and token sanitization, safely blocking arbitrary execution and injection attacks.
• Resolved Live Visualization Failures: Eliminates orphan placeholder tokens (%%%INLINE_GEOMETRY_PLACEHOLDER%%%) and unfulfilled visual promises ("See the sketch below") on visual requests like "Show me this visually"; mounts verified interactive geometry tokens and ASCII reference diagrams.
• Authoritative Deterministic Context & Safety Preservation: Verified tool results provide authoritative grounding for pedagogical explanations without weakening existing mathematical verification, prompt-to-claim fidelity, or fail-closed delivery gates.
• Capability Gap Detection & Telemetry: Transparently identifies unsupported domains (such as fluid simulations, stoichiometry, or shell scripts) without hallucinating capabilities, supported by structured telemetry across 9 standard event types.

• Practice-Problem Generation & Educational Non-Withholding Architecture: Established formal tripartite separation between generating a question, solving a question, and verifying a solution. Practice requests ("gimme another problem similar to that one", "quiz me", "give me a harder one") generate structurally validated exercises without being falsely suppressed by the fail-closed answer verification gate.
• Curriculum Skill Mapping & Structural Safety: Analyzes context to extract instructional skills (e.g. right-triangle sketches, reciprocal trig, two-step equations) and validates problem solvability, preventing contradictory premises and undefined operations with resilient candidate regeneration.
• Seamless Practice Handoff: Practice problems automatically update active session state, enabling subsequent student answers to be verified immediately by the CAS verification bridge.

• Learner-Aware Tutoring & Student State Modeling: Real-time multi-signal detection across 18 student states including self-correction with humor ("yeah i messed that all up and was doing and old problem HAHAHA"), tentative hypothesis exploration ("is this quad 4????"), spontaneous breakthroughs, confusion, discouragement, fatigue, and question-answering. Pythos acknowledges and laughs along with self-discovery rather than robotically restating formulas.
• Visual Instruction Fidelity & Dynamic Geometry Synthesis: Identifies explicit requests for visual sketches, graphs, or drawings (e.g., "using sketches find the exact value of sec(cot(-36.23))"). Automatically generates both HTML5 canvas [GEOMETRY: triangle ...] tokens and clear ASCII diagrams while strictly preventing Pythos from falsely claiming a sketch exists when none was generated.

• Interactive Stop / Generation Cancellation Control: The Send button transforms into an active Stop button (.send-btn.stop-mode) while Pythos is thinking or streaming tokens. Clicking or pressing Escape halts long mathematical proofs immediately via AbortController and stream reader cancellation.
• Sticky Vision Routing Resolution: Decoupled image attachment availability from current turn vision requirements. Subsequent text-only mathematics and physics questions route cleanly through normal deterministic and LLM pipelines even after an image upload, while legitimate visual follow-ups (e.g., "Look at the image again") remain fully supported.
• Text Model Upstream Protection: Historical image payloads are stripped before dispatching to text-only inference providers, preventing upstream schema rejections and unnecessary fail-closed withholding loops.

• Pythos Free Education License (PFEL v2.0) Documentation: Created a dedicated, accessible public documentation page at /license detailing the core philosophy, permitted commercial integrations, prohibited monetization models, and full legal terms with interactive copy tools and scrollable text.
• Navigation & Footer Links: Integrated "License" across site header navigation, mobile drawers, and footers.
• Sitemap & Metadata Indexing: Added /license to sitemap.xml with OpenGraph, Twitter Cards, and JSON-LD schema.

• Session Erasure Confirmation Auto-Focus: Modal focus is now automatically set to the "Erase Session" confirm button upon invocation, enabling rapid keyboard confirmation (Enter/Space) for mass session deletions.

• Open Development & Source Code Links: Added direct links to the official Pythos repository (https://github.com/JonScott79/Pythos) on the About and Validation pages, emphasizing open development, multi-tier deterministic verification architecture, automated test suites, and development history.
• Unified Responsive Button Layouts: Bottom actions on the About page have been unified into a single responsive, centered row with consistent typography and vertical alignment.
• Project Knowledge Service Isolation: Hardened projectKnowledgeService.js to ignore GitHub CTA button text so retrieved context remains focused during tutoring sessions.

• Mandatory Verification Pipeline for Deterministic Candidates: Deterministic solutions strictly pass through candidate extraction, AST claim verification, fidelity gating, and delivery gates before delivery, with fail-closed fallback to core CAS/LLM reasoning.
• Whole-Input Arithmetic Protection: Arithmetic fast-path matching is restricted to standalone, whole-input mathematical problems, preventing extraction of arithmetic fragments from complex prose or algebra.
• Polynomial & Calculus Substring Protection: Context boundaries defend variables, polynomials ($x^2, x^3, f(x)$), calculus notation ($d/dx, \int$), and geometry from arithmetic fragment extraction.
• Active-Problem-State Handling for Multi-Turn Arithmetic: Sequential directives (e.g. "Subtract 7 from that") dynamically evolve active problem state in contextManager.js, eliminating stale turn rediscovery.
• Formal Triangle Inequality & Oxford-Comma Parsing: Geometric triangle inequality verification ($a+b>c$) in deterministicRouter.js with robust Oxford-comma parsing (e.g. "sides 2, 3, and 10").
• Impossible-Premise Detection & Fail-Closed Delivery: Contradictory/impossible computational premises (e.g. impossible triangle perimeters) fail closed and are safely withheld rather than delivering raw explanatory strings.
• Task #6 50K Blind Benchmark Result: Across 50,000 fresh blind problems (seed 1618033988), delivered 20,602 verified-correct, safely withheld 29,398, with 0 incorrect deliveries, 0 verification escapes, and 4,832 catches. Resolved historical ADV_2001 escape.

• Mandatory Verification Gate for Deterministic Candidates: Deterministic solutions are strictly treated as candidates. They now pass through candidate extraction, claim verification, prompt-to-claim fidelity, and candidate delivery gating before delivery, with fail-closed fallback to the core LLM reasoning pipeline.
• Whole-Input Standalone Arithmetic Recognition: Arithmetic fast-path recognition is restricted to whole-input problems, eliminating loose substring matches on complex prompts.
• Universal Domain & Context Protection Boundaries: Strict protection for variables, polynomials, calculus notation ($d/dx$, $\int$), geometry concepts, and physics quantities against arithmetic fragment extraction.
• Multi-Turn Context Scoping: Sequential directives (e.g. "Subtract 7 from that") evolve active problem state, preventing stale turn rediscovery.
• 100% Verification Integrity: 20/20 dedicated Task #6 tests and all 24 master regression suites passing cleanly.

• Multi-Turn Context Revision & Error Recovery: Dynamic effective prompt reconstruction across multi-turn sessions. Invalidation of superseded mathematical states and candidate answers upon correction, with zero stale-context leaks and zero false-positive rejections.
• Input & Diagram Fidelity Ambiguity Gate: Ambiguity detection for deceptive diagram labels (e.g. $x^2$ labeled on hypotenuse) and OCR transcriptions, blocking silent reinterpretation.
• Prompt-to-Claim Fidelity Expansion: Expanded verification guards against variable/value substitution, operator mutations, and entity target mismatches, with support for explanation step decompositions.
• Adversarial & Trick-Question Hardening: 100% pass rate across contradictory premises, impossible geometric shapes (triangle inequality violations), and adversarial distractor traps.
• Master Regression Integrity: 100% passing across all 24 test suites with zero regressions.

• Quadratic Root Set Completeness: Implemented discriminant and polynomial degree analysis requiring complete root sets for quadratics ($Delta > 0$). Incomplete roots return INCOMPLETE_ROOT_SET and withhold safely.
• Coterminal Angle Fidelity Gate: Enforced principal angles in $[0^circ, 360^circ)$ and blocked intermediate arithmetic leaks (e.g. $60 + 360 = 420$) from certifying coterminal angle queries.
• Nested LaTeX Units Extraction: Implemented balanced-brace extraction for nested unit blocks like oxed{45 ext{ m/s}}, oxed{9.8 ext{ m/s}^2}, oxed{12 ext{ N}}, and oxed{100 ext{ J}}.
• Fail-Closed Null Candidate Gate: Null/empty candidate answers are strictly prevented from delivery even if claims verify. Kinematics calculations require verified physical formulas.
• Zero False-Positive Delivery (100% Precision): Replayed 1,250 immutable benchmark cases, achieving 0 incorrect delivered, 821 verified correct, and 429 safely withheld.

• In-Process Calculus Verification: Added native polynomial and rational derivative verification (verifyCalculusDerivative) to Math.js with exact symbolic differentiation and multi-point evaluation guards, delivering sub-millisecond deterministic verification with zero subprocess overhead.
• Host-Safe Bounded CAS Concurrency: Integrated BoundedCASQueue inside verificationBridge.js, preventing host contention and pipe lockups across concurrent worker pools.
• Subprocess Lifecycle & Pipe Management: Hardened stdio cleanup (destroying stdin, stdout, stderr) and ensured child process termination completes before releasing concurrency slots on timeout or error.
• Calculus Claim Schema Alignment: Aligned proposed_derivative and proposed_value properties across the verification bridge and Python SymPy verifier.
• 100% Regression Green: Re-verified all 15 previously withheld calculus cases (80001–80015) in under 1ms, passing all concurrent calculus and master regression suites.

• Multi-Variable Systems Verification: Implemented deterministic multi-variable solution verifier (verifySystemSolution) and unified claim extraction for two-variable linear systems, recovering 100% of previously withheld systems cases.
• Robust Geometry Context & Visual Extraction: Resolved scoping reference in deterministicRouter.js, populated solution metrics on GEOMETRY_VIZ intents, and enhanced regex extraction for markdown-formatted right-triangle side measurements.
• Function Notation Guard & Evaluation: Added native polynomial evaluation (verifyFunctionEvaluation) for $f(k)$ queries and shielded function definition notation from being misparsed as equations to solve.
• Complete 10,000-Problem Ablation Replay: Verified delivery expanded from 8,530 to 10,000 (100.00%) with 0 incorrect delivered, recovering all 1,470 withheld ablation cases with zero regressions.
• Fresh 11,000-Problem Blind Validation: Validated 1,000 independent problems across all 11 domains with fresh seed (1414213562), delivering 11,000 / 11,000 verified correct (100.00%) with zero escapes.

• Right-Triangle Visual Intent Routing: Added qualitative visual intent detection so requests like "can you show me on a triangle?" render an illustrated 3-4-5 right triangle with verified ratios ($sin heta=3/5$, $cos heta=4/5$, $ an heta=3/4$) and hypotenuse cancellation proof.
• Robust JSON Parser & Multi-Quote Support: Enhanced visualization extraction and escape repair to gracefully handle Python/LLM single-quoted keys and trailing commas.
• Shielded Student-Facing Fallback UX: Eliminated technical JSON parser error strings and stack traces from student view upon visualization failure, presenting a graceful step-by-step guidance message instead.
• Context Contamination Elimination: Fixed problem classification and contraction cleaning for trigonometric follow-ups ("isnt tan sin/cos"), preventing irrelevant algebraic extraneous root checks from leaking into conversations.

• 110K Blind Online Validation Campaign: Completed 110,000-problem campaign (v1.8.9-online-validation, seed 2718281828) with 100% remote Groq Cloud model (openai/gpt-oss-20b) and deterministic CAS verification.
• 110,000 / 110,000 Verified Correct (100.00%): 110,000 verified correct, 0 incorrect delivered, 0 safely withheld, 0 verification escapes, 0 false-positive rejections.
• All 11 Domains at 100%: 10,000 problems each in Arithmetic, Fractions, Linear Equations, Systems, Quadratics, Functions, Geometry, Trigonometry, Calculus, Probability, and Physics.
• Repaired Linear Router Confirmed: Fixed linear equation parsing, delivering 10,000/10,000 verified solutions with zero safe-withholding fallout.
• Remote Candidate Architecture & Checkpointing: Shifted LLM inference to Groq Cloud (132.1 MB peak heap, 0 provider faults); survived sleep/wake events without state loss.
• Dedicated Suites Passed & Honest Bounds: All 9 dedicated suites passed (Vision, Kid Safety, Multi-Turn, Backup-Brain, etc.). Finite benchmark; universal correctness not claimed.

• UI/UX Workspace Ergonomics: Interactive Pythos Oracle welcome card on new chats with starter problem chips (algebra, calculus, kinematics, graphing), refined mobile toolbox, touch targets, and compact input ergonomics.
• Standardized Site Navigation & Mobile Menus: Unified header and footer navigation across study guides (subjects/, algebra/, calculus/, physics/) and informational pages, featuring responsive mobile toggle menus and the Mission & Roadmap label.
• Microsoft Clarity Integration & Privacy Masking: Embedded asynchronous Microsoft Clarity analytics with strict zero-leak privacy masking (data-clarity-mask="true") across chat messages, inputs, diagram attachments, and memory ledgers.
• Canonical Identity & 3-Layer Verification: Standardized attribution to the Pythos education initiative developed by LANZAR, documented the 3 distinct verification layers (Math.js, SymPy, Pythos Verifier), and separated current availability from the future 501(c)(3) roadmap.
• Transparent User Memory Ledger: Documented the student-facing, user-controlled Memory Ledger for inspecting and deleting stored learning entries.

• Verified Backup-Brain Recovery Gateway: Automated failover for primary LLM infrastructure failures (connection drops, socket timeouts, 5xx server errors, blank responses) to an independent, hosted backup brain (groq-text / openai/gpt-oss-20b).
• Strict Verification Invariance: Candidate solutions from the backup brain pass through the exact same verification pipeline (atomic claims extraction, prompt-to-claim fidelity, deterministic Math.js / SymPy CAS evaluation, automated revision with re-verification, Deterministic Supremacy CAS replacement, and delivery gate). Unverified or mathematically invalid backup claims are never delivered.
• Strict $0 Cost Guardrail & Token Discipline: Both primary and backup providers operate in free_only mode (freeEligible: true) with automated prompt compaction enforcing Groq's 8,000 TPM limit. Normal successful primary requests incur zero backup calls and zero token overhead.
• Fail-Safe Safe Withholding: If both primary and backup reasoning engines are unavailable, the system safely withholds and returns an explicit 503 error, adhering strictly to the safety principle: WRONG > UNKNOWN: NEVER.

• Authoritative Self-Knowledge & Site Grounding (LARRY): Integrated dynamic site-source grounding for conversational inquiries regarding Pythos accuracy, creator attribution, mission, curriculum guides, and release history with zero token overhead on math.
• Container Source Parity & Multi-Path Resolution: Resolved Railway container build isolation by bundling canonical site sources in server/site_sources/ with dual-path fallback resolution.
• Pretraining Bias Mitigation & Identity Mandate: Enforced strict prompt directives prioritizing official site sources over base LLM priors, affirming Jon Scott (LANZAR) creation and citing 95.81% verified math accuracy across 50,000 blind problems (0 wrong delivered).
• Token-Efficient Source Cleaning & Acceptance Suite: Compact HTML extraction (< 350 tokens) and complete live multi-turn conversational acceptance validation.

• Public Mathematical Validation Record (/validation/): Launched a transparent, permanent public engineering validation record publishing current verified mathematical benchmarks (50,000 problems tested, 47,907 verified correct [95.81%], 2,093 safely withheld [4.19%], 0 incorrect answers delivered [0.00%], 0 escapes, 0 false positives, 95% CI [0.0000%, 0.0077%]). Includes full operational telemetry (runtime, peak heap, CAS concurrency, orphan process audits), detailed domain breakdowns across 10 subject areas, documentation of the “Safely Withheld” UNKNOWN philosophy, and a 6-stage deterministic verification pipeline diagram.
• Official Facebook Link Integration: Connected official Pythos Facebook community portal (https://www.facebook.com/PythosAI/) in sidebar navigation, quick actions, and footer across all site pages.
• Unified Site Navigation & Discovery: Added direct validation record links across all subject guides (algebra/, calculus/, physics/), interactive tools (tools/), foundational pages (about/, nonprofit.html), and XML sitemap (sitemap.xml).

• Prompt-to-Claim Mathematical Fidelity Verification: Implemented checkPromptClaimFidelity in the verification pipeline. Verification now proves both internal mathematical truth and fidelity to the user's requested problem. Employs multiset operand leaf comparison and Math.js AST traversal to ensure verified claims structurally correspond to the requested problem, rejecting mathematically true statements that answer a different or coincidental problem (e.g. $500 - 571 = -71$ for prompt $-194 + 123$) while strictly preserving legitimate intermediate calculation steps (e.g. $3 + 4 = 7$ in $2 \times (3 + 4)$) and equivalent rational representations ($1/2 = 0.5$).
• Original User Query Propagation in Verification Pipeline: Explicitly propagated the authentic user prompt through extractClaims(content, userQueryText) and runDeterministicVerification(claim, userQueryText). Prevents verification from evaluating claims against fallback assistant response strings or default empty contexts.
• Targeted Fidelity & Extended Validation Test Suites: Established a targeted 6-case prompt-fidelity regression suite, 1,500-problem Development Benchmark v3, and an unseen 1,500-problem Development Benchmark v4 covering signed arithmetic, double negatives, conversational preambles, fraction amputation resistance, compound operations, and cross-domain invariants. Both 1,500-problem benchmarks achieved 100% resolution with 0 wrong delivered and 0 unknown.

• Negative Operand Extraction & Markdown Bullet Collision: Hardened leading hyphen stripping in extractArithmeticExpressions to require whitespace followed by an alphabetic character (^-\s+(?=[a-zA-Z])). Prevents legitimate leading negative signs on numbers, decimals, parentheses, and fractions (e.g. -992 - -988, -194 + 123) from being stripped as list formatting bullets.
• Generalized Conversational Calculation Prefixes: Generalized natural language wrapper removal across calculation directives (“What is the result of”, “Please calculate”, “Determine”, “Help me evaluate”, “Solve for the value of”) without prompt-specific hardcoding, reliably preserving leading negative signs and expressions beginning with operators or parentheses.
• Infix Fraction Amputation Defense: Hardened infix arithmetic extraction regex to treat signed rational operands (-?\d+\s*\/\s*\d+), decimals, and parenthesized expressions as atomic units, preventing compound fraction expressions (e.g. $5/14 - 1/6$) from amputating into trailing sub-expressions (e.g. $14 - 1/6$).
• Strict IEEE 754 Machine Precision Tolerance: Bounded floating-point exact matching to machine epsilon ($< 10^{-11}$) to eliminate false-negative rejections caused by JavaScript floating-point binary representation artifacts.

• Multi-Modal Vision & Text Parity Architecture: Reconciled vision-extracted problem state with multi-turn dialogue history. When problems originate from uploaded images or handwritten diagrams, Pythos records extracted problem expressions and domains into conversational context, ensuring multi-turn student follow-ups (“Is my step right?”, “What do I do next?”) operate with identical state awareness to text-based dialogues.
• Handwritten Student Work Verification & Error Diagnosis: Enabled fast-path deterministic evaluation of student-submitted intermediate steps on image-extracted problems. Added linear equation equivalence verification ($3x + 7 = 22 \rightarrow 3x = 15$) to isolate arithmetic errors ($3x = 16 \rightarrow \text{arithmetic error: } 22 - 7 = 15$) and validate operations before LLM generation.
• Compound Validation & Visualization Intent Handling: Enhanced intent classification to recognize compound intents combining work validation with visualization requests (“Is my step 3x=15 right? Can you graph it?”). Ensures tutoring validation executes while simultaneously dispatching visualization directives without state collision.
• Analytical Trigonometric Modeling & Right Triangle Geometry: Added support for LaTeX degree notations (^\circ, ^{\circ}, \text{°}) and analytical angle deduction from side ratios ($\theta = \arcsin(\text{opp}/\text{hyp})$) in right-triangle geometric problem spaces, generating mathematically accurate interactive instrument schemas.
• Production Runtime & Environment Reconciliation: Aligned production containerization to node:22-alpine with system Python 3 and SymPy (py3-sympy), satisfying firebase-admin@14.3.0 engine requirements (Node $\ge 22$) and guaranteeing full parity between local and production second-line CAS verification. Upgraded health probe telemetry to report CAS engine readiness.
• Multiline Text Input & Shift+Enter Line Breaking: Upgraded the primary problem input (#userInput) to an accessible, auto-resizing multiline text area. Pressing Shift+Enter now creates a new line for composing multi-step equations, proofs, and formatted queries, while pressing Enter immediately dispatches the problem. Includes dynamic viewport height auto-expansion up to 180px with scroll containment.

• KaTeX Fraction & Mathematical DOM Order Extraction: Resolved a display/extraction inversion bug where reading .textContent from KaTeX-rendered .mfrac DOM elements extracted denominator before numerator due to KaTeX's vertical alignment layout (e.g. $\frac{17\pi}{5} \rightarrow \text{“517}\pi\text{”}$, $\frac{7\pi}{5} \rightarrow \text{“57}\pi\text{”}$, $\frac{\pi}{2} \rightarrow \text{“2}\pi\text{”}$). Implemented latexToMathText() and extractKaTeXDomText() to recover visual/mathematical ordering ($\text{“17}\pi\text{/5”}$), enabled htmlAndMathml output with LaTeX <annotation> tags for screen readers, and enhanced final answer box accessibility labeling.
• Verification Engine Token Capture & Parentheses Arithmetic: Corrected a regex capture group flaw in arithmetic claim extraction that captured only trailing tokens rather than the complete arithmetic expression during multi-token calculations (e.g. $345(180/\pi) = 19768.46$). Restored full arithmetic extraction across parentheses, fractional multipliers, and coterminal angle conversions.
• Form Submission Lock & Concurrency Hardening: Hardened the multiline input submission lifecycle against double-triggering by enforcing an immediate isProcessing submission lock, ignoring IME composition (keyCode 229) and keyboard repeat events, and explicitly preventing parent .input-wrapper form submit bubbling.

• Multi-Turn Destruction Testing & Child-Readiness Certification: Certified Pythos against a comprehensive 1,004-conversation, 2,176-turn adversarial destruction battery covering math/physics topic switching, interruptions (“wait”, “hold on”), self-corrections, third-party/calculator claims, terse answers, random mutations, and long-context dialogue torture up to 250 turns with zero failures.
• Mathematical Payload Extraction on Self-Corrections (P1): When students self-correct with mathematical work (e.g. “Actually I meant 4x = 20”), Pythos extracts the mathematical clause and verifies it against the active problem rather than dropping into an intent-only state.
• Chronological Topic Restoration in Long-Context Dialogues (P1): Topic restoration requests (“Can we go back to problem 1?”) are now resolved chronologically inside the dialogue traversal loop, ensuring restored problem context persists across subsequent turns in 50+, 100+, and 250-turn dialogues.
• Unverified Student Guess State Shielding (P0): Prevented candidate answers (e.g. F = 8) and physics domains from polluting activeExpression, ensuring student operational errors are diagnosed and corrected rather than self-verifying.
• Third-Party & Authority Claim Verification (P1): Added deterministic extraction and evaluation for student claims citing teachers, calculators, textbooks, and third parties (“My teacher said the answer is 4”, “My calculator says x = 5”).
• Conversational Slang & Idiomatic Expression Tolerance (P1): Relaxed strict string termination to allow trailing slang and emphatic phrases (“x = 5 no cap”, “2x = 8 eureka!”, “x = 4 periodt”) without diverting valid math to UNKNOWN.
• Kinematics Velocity Verification (P1): Expanded physics evaluation to include acceleration-to-velocity calculation ($v = a \times t$) alongside distance ($d = v \times t$) and Newtonian dynamics ($F = m \times a$).
• Implicit Problem Abandonment & Equation Partitioning (P1): Distinct new equations (e.g. 5y - 10 = 15) seamlessly archive earlier problems and establish new active tasks without requiring the explicit phrase “new problem”.

• Nonprofit Educational Mission Page: Published Pythos Nonprofit Mission (nonprofit.html) outlining our long-term mission to establish a registered nonprofit, keep AI-powered math and physics tutoring permanently free, support educators, and create direct software-building opportunities for young developers.
• Contextual Step Validation (P1): When students ask “Is this right?” or “Did I do this right?” following a proposed intermediate step (e.g. 3x = 15), Pythos now directly validates the specific proposed transformation first, explains the arithmetic (3x + 7 - 7 = 22 - 7 gives 3x = 15), and guides the next step (Next, divide both sides by 3) rather than restarting or regenerating the entire problem derivation.
• Adversarial Error Correction (P1): Incorrect proposed steps (e.g. 3x = 16 for 3x + 7 = 22) are specifically diagnosed and corrected (❌ Not quite. Subtracting 7 from 22 gives 15, not 16), affirming valid methodology while keeping the active equation state accurate.
• State-Authoritative Continuation (P1): The CONTINUATION intent (“Continue.”) strictly adheres to the active state machine. If the problem is completed (x = 5), Pythos acknowledges completion without repeating substitution checks; if incomplete, Pythos advances directly to the next operation without restarting.
• Mathematical Presentation & Fraction Rendering Polish (P1): Enforced explicit fraction bar borders (.frac-line) and clipped KaTeX MathML duplication in CSS. Hardened client regex normalizers for negative rational expressions, LaTeX fractions, and division presentation.

• Per-User Learning Store Isolation (P0): Verified learning corrections are now strictly partitioned by authenticated student UID under users/{uid}/pythos_learning/{recordId}, eliminating cross-user learning data leakage across sessions and container restarts.
• Deterministic Student Intent Classification (P1): New multi-signal deterministic classifier identifying 11 distinct student conversational intents (proposed answers, proposed steps, validation requests, corrections, reframe requests, confusion, etc.) prior to LLM reasoning.
• Student-Proposed Math Evaluation & Check-My-Work (P1): Deterministically evaluates student-proposed mathematical steps and exact rational $\pi$ arithmetic (e.g. -29/3 pi + 2pi * 5 evaluates to $\pi/3$) before model generation. Ambiguous notations (such as 1/2x or sin 30) are safely tagged as ambiguous without guessing.
• Mandatory Revision Re-Verification (P1): When initial LLM generations contain invalid claims, the resulting revision is now fully re-verified deterministically before sending to ensure secondary errors are caught.
• Generalized Algebraic Claim Extraction (P2): Generalized linear and quadratic equation extraction with direct root substitution verification in Math.js.

• Explicit Firestore Security Rules (P0): Added explicit Firestore security rules for pythos_memory and pythos_learning, permitting authenticated users to read only their own data while strictly denying all client-side writes.
• Memory Poisoning Defense (P1): Memory extraction rejects attributed speech (“my friend says my name is...”), quoted speech, hypotheticals, negated names, and false mathematical propositions (“remember that 2 + 2 = 5”) from entering persistent memory.
• Identity Authority Hierarchy: Maintains strict authority separation: Authenticated Account Identity > Verified Math Facts > Student Explicit Statements > Conversation Context > LLM Inference.
• Comprehensive Regression Verification: 18 test suites and 197/197 tests passing (100% green).

• Trusted Identity Metadata Architecture: Canonical student identity from Firebase Authentication is now cryptographically extracted server-side and injected directly into the model reasoning context, decoupling account identity from learned personal memory.
• Zero-Latency Name Resolution: Pythos accurately and reliably knows the student's name when asked (e.g. "what's my name?"), even in fresh sessions or after extensive multi-turn problem solving, without requiring explicit chat re-introductions.
• Display Name Input Sanitization: Input sanitization protects against prompt injection, stripping control characters, newlines, and brackets while bounding display names to 60 characters.

• Strict Cross-User Isolation: Identity metadata is extracted strictly per-request from verified Firebase JWT tokens; concurrent interleaved student sessions can never cross-contaminate.
• Anti-Spoofing Security Boundary: Client-provided display names are strictly ignored unless authenticated by a valid cryptographic token.
• Anti-Hallucination & Natural Conversation Rules: Explicit prompt guardrails prevent Pythos from inventing or guessing names for unauthenticated guests, while instructing Pythos not to mechanically spam the student's name in ordinary tutoring turns.
• Full Regression Verification: 7/7 dedicated identity regression suites passing (100% green); 355/355 tests passing across all 13 regression suites.

• Gemini Secondary Vision Backup: Integrated Google Gemini (gemini-2.5-flash) as an automated secondary backup provider when the primary Groq Qwen vision provider is rate-limited or unavailable.
• Multi-Provider Fallback Gateway: Seamless automated fallback loop in /api/chat supporting both streaming (NDJSON) and legacy (JSON) interfaces without student session interruption.
• Centralized Credential Resolution: Consolidated API credential getters in providerPolicy.js with centralized resolution for Groq and Gemini.

• Operator Free-Tier Certification Requirement: Google AI Studio does not expose an API endpoint to query billing status. Under PYTHOS_AI_BUDGET_MODE=free_only, Gemini fails closed (freeEligible: false) unless an operator explicitly certifies zero-cost status via GEMINI_FREE_TIER=true. Paid providers can never be invoked.
• Execution Layer Defense-in-Depth: executeVisionCall independently validates budget mode, kill switch, and provider status to ensure policy cannot be bypassed.
• Security & Error Taxonomy Sanitization: Redacted AIzaSy... keys and x-goog-api-key headers in error traces; classified Gemini RESOURCE_EXHAUSTED and quota errors as UPSTREAM_RATE_LIMITED (429).
• Full Suite Verification: 24 new unit, adversarial, and end-to-end fallback verification tests; 348/348 tests passing across all 12 regression test suites.

• $0 Provider Wall Regression: Fixed a configuration mismatch where providerPolicy.js checked only process.env.GROQ_API_KEY while server.js resolved the Groq key with an embedded fallback. When the env var was unset (the default deployment), the vision provider was incorrectly rejected at the configuration filter before the budget guardrail was ever evaluated, producing “Vision reasoning is temporarily unavailable.”
• Vision Error Diagnostics: Distinguished NO_CONFIGURED_PROVIDER in the vision error handler so legitimate configuration failures now produce specific, actionable messages instead of the ambiguous generic fallback.

• 6 New Regression Tests: Proves embedded fallback key detection, free-eligible providers with paid plans are not blocked, unconfigured providers are correctly rejected, and production registry vision/text selection works end-to-end. Total: 20/20 cost guardrail tests passing.
• Full Suite Green: All 191/191 accessibility tests, vision timer tests, error taxonomy tests, and 7/7 deterministic router tests pass with zero regressions.

• $0 Cost Guardrail Fully Preserved: Paid providers remain strictly forbidden under free_only mode. Emergency kill switch, deterministic math fast paths, vision timer, and error taxonomy all unaffected.

• $0 AI Cost Guardrail (PYTHOS_AI_BUDGET_MODE): Hard infrastructure policy guaranteeing that Pythos never incurs AI API charges unless paid spending is explicitly enabled (paid_enabled). Missing, invalid, or malformed settings fail closed to free_only.
• Architectural Provider Selection Layer: Centralized selection router (server/providerPolicy.js) that checks provider eligibility, capabilities, configuration state, and rate limits. Configured paid models are strictly forbidden in free_only mode.
• Intelligent Free-Tier Fallback: When a free vision provider returns 429, searches for secondary free-eligible providers before falling back to UPSTREAM_RATE_LIMITED and triggering the vision capacity timer. Paid providers cannot be accidentally reached.
• Emergency Infrastructure Kill Switch (PYTHOS_AI_ENABLED): Single-variable emergency control to instantly halt all external AI calls without redeploying code. Cleanly communicates temporary maintenance while keeping fast-path mathematical solvers functional.
• Privacy-Safe Budget Telemetry: Exposed on /health for administrative monitoring with complete redaction of API keys, Bearer tokens, and secrets.

• Automated Cost Guardrail Suite: 16 dedicated unit, regression, and live API integration tests in test_cost_guardrail.js proving zero-cost enforcement, fail-closed mechanics, and credential sanitization.
• Zero Regressions: All 93/93 core mathematical CAS benchmark tests, error taxonomy tests, vision capacity timer tests, and 190/190 accessibility audits passed.

• Vision Capacity Countdown Timer: When upstream multimodal vision inference hits rate limits (UPSTREAM_RATE_LIMITED), the existing Image / Photo button dynamically transforms into an active countdown timer ([ ⏳ MM:SS ] / [ ⏳ H:MM:SS ]).
• Single Status Indicator Design: Avoids separate widgets, token balances, or quota clutter. The button itself serves as the singular feedback point, updating once per second until provider recovery.
• Client-Side Multi-Modal Protection: Prevents redundant upload requests client-side while counting down. Protects toolbar clicks, secondary camera button clicks, drag-and-drop zones, and clipboard paste (Ctrl+V / Cmd+V) with helpful student guidance.
• Uninterrupted Math & Physics Workflow: Text chat, symbolic calculation, interactive graphing, equation editing, units conversion, and matrix tools remain 100% active and unblocked during vision cooldowns.
• Automatic Dynamic Reset: When the countdown reaches zero, the original Image / Photo button and camera icon are cleanly re-enabled with full accessible titles and SVG icons restored.

• Dedicated Timer Test Suite: Full coverage in test_vision_timer.js verifying exact second formatting (1094s -> 18:14, 65s -> 01:05, 3600s -> 1:00:00), 0/negative/NaN edge cases, clean replacement on new 429s, and button restoration.
• Universal Regression Continuity: Passes all 93/93 core mathematical benchmark tests and 189/189 accessibility tests (WCAG 2.2 AA).

• Standardized Upstream Error Taxonomy: Introduced server/errorHandler.js to classify infrastructure failures deterministically across 8 distinct categories (UPSTREAM_RATE_LIMITED, UPSTREAM_TIMEOUT, UPSTREAM_AUTH_ERROR, UPSTREAM_BAD_REQUEST, UPSTREAM_SERVER_ERROR, UPSTREAM_UNAVAILABLE, INVALID_IMAGE, INTERNAL_ERROR).
• Student-Friendly Reassuring Language: Replaced misleading "knowledge base" errors with honest explanations (e.g., "⏳ The vision reasoning service is temporarily busy with high demand.").
• Parsed Dynamic Retry Estimates: Extracts exact wait times from provider response bodies and headers to inform students when to retry without guessing or manufacturing arbitrary recovery times. Guaranteed safe against negative or 0-minute outputs.
• Credential & Privacy Scrubbing: Complete redaction of Groq API keys, Bearer tokens, organization identifiers (org_...), internal server filesystem paths, and base64 payloads from logs and responses.

• Dedicated Taxonomy Test Suite: Full coverage in test_error_taxonomy.js verifying all 8 failure conditions, credential redaction, and API error contracts.
• Core Regression Continuity: Universal regression suite passes 93/93 tests (100% core integrity, 0 regressions).

• Mobile Phone Image Compatibility (.heic & .heif): Full native and client-side conversion support for Apple HEIC/HEIF photos across iOS devices, mobile browsers, and desktop platforms. Integrates a vendored WebAssembly transcoding engine (assets/vendor/heic2any.min.js) with automatic CDN fallback, seamlessly converting phone photos to JPEG Blobs prior to upload.
• Binary Magic Byte Sniffing: Replaces naive extension/MIME checks with binary inspection of ISO BMFF headers (ftyp brands: heic, heix, hevc, heim, mif1, etc.), guaranteeing accurate format detection even when mobile operating systems supply generic application/octet-stream MIME types.
• EXIF Auto-Orientation Normalization: Uses modern createImageBitmap(blob, { imageOrientation: 'from-image' }) to automatically detect and correct EXIF orientation metadata, ensuring sideways or upside-down phone photos are rendered upright before vision model inspection.
• Universal Upload Channels: File picker (<input accept="...">), drag-and-drop dropzones, and clipboard paste (Ctrl+V / Cmd+V) accept .heic, .heif, .jpg, .jpeg, .png, .webp, and .bmp.
• Backend Payload Validation & Security Gate: validateBase64Image checks magic byte headers on all inbound image payloads. Corrupted, truncated, or spoofed uploads are rejected with HTTP 400 (invalid_image) and user-friendly error dialogs, protecting upstream vision quota.

• Phone Format Audit Suite: Verified across a 15-test matrix covering valid, rotated, 12MP high-resolution, truncated, and disguised binary formats, confirming 100% accurate format sniffing and corrupt payload rejection.
• End-to-End Pipeline Integrity: Converted HEIC math worksheets, handwritten calculus limits, and physics circle diagrams successfully passed end-to-end vision extraction, reasoning, and deterministic verification.
• Core Regression Continuity: Universal regression suite passes 93/93 tests (100% core integrity, 0 regressions).

• Multimodal Vision Input Pipeline: Complete end-to-end vision processing for real-world homework worksheets, handwritten equations, graphs, geometry diagrams, and physics problems. Integrates client-side HTML5 Canvas compression (capping resolution to 1600px, 200KB–400KB) across drag-and-drop, native file picker, camera snapshots, and clipboard paste (Ctrl+V / Cmd+V).
• Pedagogical Multimodal Directives: Rigorous system directives requiring the vision inference model to strictly separate original printed problem statements from student handwritten attempts, ensuring student work is never assumed correct without independent verification.
• Visual Ambiguity & Confidence Gate: Integrated into server/verificationBridge.js. Detects degraded, crossed-out, or ambiguous handwritten tokens (e.g. 3x vs. 8x, ± vs. +, t vs. +) and surfaces uncertainty to the student, strictly preventing contaminated visual interpretations from entering the deterministic CAS verification engine.
• Production Vision Inference Architecture: Hosted production integration with qwen/qwen3.8-27b, providing sub-second time-to-first-token, LaTeX transcription, and resilient backoff handling across upstream rate limits and capacity pressures.
• Privacy & Firestore Document Protection: Raw base64 image strings are completely sanitized and stripped prior to database persistence, guaranteeing conversation document sizes remain well under 1MB.

• Online Multimodal Torture Suite: test_online_torture.js passing 8/8 comprehensive live torture benchmarks covering geometry circle theorems, AP Physics inclined planes with friction, multi-turn conversational follow-ups, crossed-out work, arithmetic error detection, and shadowed/skewed photos.
• Failure States & Resiliency Suite: test-failure-states.js passing 6/6 tests covering unreadable payloads, malformed requests (400), oversized payloads (413), provider timeouts, and ambiguity gating.
• Full Regression Continuity: Universal regression suite passing 92/93 tests (100% core integrity, 0 regressions) and accessibility suite passing 186/186 tests.

• Personal Memory System: Durable, cross-session personal memory architecture built under users/{uid}/pythos_memory/ in Firestore. Pythos naturally remembers a student's preferred name, course/grade level, explanation pacing (concise vs. detailed), analogy preferences (sports, gaming), and active learning weaknesses without repeating robotic meta-announcements.
• Controlled Extraction Pipeline: Multi-stage, non-blocking asynchronous extraction worker that runs post-response. Distinguishes observed explicit facts (confidence ≥ 0.90) from behavioral inferences (confidence ~0.50), applying asymptotic reinforcement over repeated interactions.
• Strict Minor Safety & PII Redaction: Automatic deterministic filtering against addresses, phone numbers, emails, passwords, and sensitive personal topics.
• Compact Token-Budgeted Injection: Dynamic compilation into a bounded prompt injection block (≤ 150 tokens) filtered by current problem domain to prevent context window bloat.
• Student Transparency & Control: Interactive modal ("🧠 What Pythos Remembers") allowing students to review remembered traits, view original quote evidence, remove individual items, or perform a total memory wipe ("Forget Everything").
• Calculator Direct Keyboard Typing: Students can now directly enter expressions into the on-screen calculator using their hardware keyboard (numbers, operators, exponents, decimals, parentheses, Enter to evaluate, Escape to clear), retaining exact parity with the button pipeline and decimal CAS protection.
• Trigonometry & Standard-Position Angle Router Guard: Distinguishes angle and geometry queries from generic function graphing (GRAPH_PLOT), eliminating bug where natural-language angle homework was treated as an algebraic $f(x)$ curve. Injects verified ANGLE_STANDARD_POSITION facts into the pedagogical tutor, respecting constraints like "without converting to degrees" purely in radian fractions.

• Dedicated Memory Test Suite: Added test/test-memory-system.js verifying fact/inference extraction, PII denial, context formatting, token bounds, and Firestore persistence. 100% passing.
• Angle & Routing Regression Suite: Added test-angle-routing.js covering real-world homework prompts, standard-position coterminal reductions, quadrant determinations, and function plot preservation. 100% passing.
• Calculator Keyboard Parity Suite: Added test-calculator-keyboard.js testing keyboard vs. button evaluation parity, decimal handling, and accessibility focus states. 100% passing.

• Firebase Bug Report Persistence & Query Layer (Phase 3C): Complete Firestore integration for durable bug report lifecycle management under the pythos/app/bug_reports namespace. Resolves ephemeral Railway filesystem wipes — reports remain queryable and reviewable across redeployments. Seamless local filesystem fallback is maintained for offline development.
• Hidden Authenticated Admin Console (Phase 3D): Standalone admin portal located at admin/index.html (unlinked from public navigation). Authenticates active administrators via Firebase Google Authentication and backend ID token verification against /admins/{uid}.active == true. Features report filtering, detailed inspect views, raw interaction transcripts, CAS verifier claims, and review status management without exposing client API keys.
• Telemetry Isolation & Queue Classification: Explicit classification between real student submissions (student), automated mathematical flags (system_auto_flag), and test harness fixtures (test). Default admin views isolate genuine user reports.
• Administrative Report Lifecycle & Deletion: Real-time lifecycle state updates and complete report deletion via DELETE /admin/reports/:reportId across both disk and Firestore.
• AI Pair-Programming Incident Export: Built-in tools to export single incident dossiers as formatted Markdown (.md) or raw JSON, plus bulk queue bundling for rapid root-cause analysis and automated regression test generation.
• Security Rules Hardening: Client-side creation of bug reports is strictly denied in Firestore security rules (allow read, write: if isAdmin();). Bug submissions are channeled through POST /api/report with server-side PII sanitization and Firebase Admin SDK privilege.
• Phase 3E Evaluation: User profile document requirements formally evaluated and documented as deferred — student sessions remain cleanly keyed under existing users/{uid}/pythos_chats/{chatId} without redundant collections.

• 12/12 Master Regression Suites Passing (100%): Added dedicated Suite 12 covering Firebase Admin Authentication, ID Token verification, active admin permissions, report listing/detail, queue filtering, review state transitions, report deletion, incident export endpoints, and administrative reporting toggles. All 266 SymPy tests, Math.js adversarial cases, and reasoning suites passing.

• Accessibility Audit & Fixes (WCAG 2.2 AA): Comprehensive front-end accessibility pass across all pages. Math Guide interactive items converted from non-interactive <div> elements to keyboard-focusable <button> elements with descriptive aria-label attributes, enabling full keyboard navigation of the symbol/syntax reference.
• Starter Phrase Keyboard Access: Conversation starter phrases in the Math Input Guide converted from <span> to <button> elements, making them keyboard and screen-reader accessible.
• ARIA Label Coverage: Added aria-label to Login/Logout buttons, report modal Cancel and Submit buttons, and decorative SVG arrows across all satellite pages.
• Sidebar Overlay: Mobile backdrop overlay correctly marked aria-hidden="true" — it is a visual-only element not requiring screen-reader interaction.
• Report Modal Semantic Fix: Replaced orphaned <label> (unassociated to any input) for the context snippet with a properly labelled role="region" using aria-labelledby.
• Twitter Card Image Alt (about/index.html): Added missing twitter:image:alt meta tag.

• 186/186 Tests Passing (100%): All existing regression tests pass. Test suite updated to track v1.3.1 version anchors.

• General Premise-Data Consistency Auditing (logic_verifier.py, reasoningVerifier.js): Automatically audits user-asserted premises against underlying dataset arithmetic. Detects and flags PREMISE_DATA_CONTRADICTION with precise counterexample metrics before premises can be adopted into mathematical deductions.
• Strict Simpson's Paradox Defining Condition (statistics_verifier.py): Eliminates false-positive classifications on datasets with mixed subgroup directions. Simpson's paradox strictly requires that all subgroups share a uniform directional advantage and that the aggregate reverses that direction.
• Dynamic Subgroup Entity Extraction (deterministicRouter.js): Discovers and pairs arbitrary entity identifiers ($X$ vs $Y$, Program $X$ vs $Y$, Treatment vs Control) and injects preflight premise contradiction directives into the reasoning context.

• 11 Master Test Suites Passing (100%): Master regression runner (test-regression-harness.js) now includes Suite 11 (test-premise-consistency.js) providing 4-tier adversarial coverage across premise consistency and phenomenon entailment.

• Classical Interactive Visualization Engine (vizEngine/): Trusted, schema-validated client visualization framework rendering Aegean-styled instruments with Ancient Greek typography (Cinzel), marble tablets, and responsive sliders. Includes 9 local simulation models: Projectile Motion (ΒΛΗΜΑ), Newton's Second Law (ΔΥΝΑΜΙΚΗ), Energy Conservation (ΕΝΕΡΓΕΙΑ), Momentum & Collisions (ΟΡΜΗ), Hooke's Law (ΕΛΑΤΗΡΙΟΝ), Wave Mechanics (ΚΥΜΑ), DC Circuits (ΚΥΚΛΩΜΑ), Unit Circle Trigonometry (ΤΡΙΓΩΝΟΜΕΤΡΙΑ), and Differential Calculus (ΑΠΕΙΡΟΣΤΙΚΟΣ ΛΟΓΙΣΜΟΣ). Features full LLM system prompt awareness of the [VIZ: ...] protocol, natural-language intent routing, and responsive wide viewport presentation placing simulations and controls side-by-side on desktop ($\ge 900\text{px}$) with zero vertical scrolling.
• Accessible Markdown Tables: Full GitHub-Flavored Markdown table parsing in the zero-flash streaming pipeline with horizontal scroll protection and LaTeX cell compatibility.
• Student Problem Reporting System (reportService.js): Student-facing 🐞 Report a Problem modal dialog, immutable daily JSON audit logging, administrative review lifecycles, student PII redaction, and dynamic runtime feature flags.
• Deterministic Logical Reasoning Layer (logic_verifier.py): Decoupled tri-aspect verification, unstated assumption auditing, and automated counterexample generation for invalid algebraic inferences.
• Pedagogical Pacing & Adaptive Notation: Instant short-circuiting for trivial arithmetic ($15 \times 4$), progressive algebraic pacing, and adaptive multiplication notation ($\times \to \cdot \to$ juxtaposition).

• 100% Pass Across 9 Master Test Suites: Unified regression runner (test-regression-harness.js) verifying CAS mathematics, Math.js adversarial edge cases, tri-aspect logic, reporting lifecycles, PII minimization, pedagogy routing, structured tokens, table formatting, and the visualization engine.

• Specialized Problem Classifier & Routing Engine (problemClassifier.js): Automatically identifies 12+ problem domains including ARITHMETIC, ALGEBRA, CALCULUS, PROBABILITY, STATISTICS, PHYSICS, TRIGONOMETRY, and CONCEPTUAL reasoning.
• Two-Stage Reasoning Architecture: Rigorously separates Stage 1: Situation & Model Identification (identifying boundary constraints and potential traps) from Stage 2: Mathematical Derivation (exact step-by-step verified LaTeX solutions).
• Pre-Flight Deterministic CAS Ground Truth (deterministicRouter.js): Instant computation (<1ms) of mathematical constraints (e.g. 3-sided river fencing optimization, two-machine Bayes defect posteriors, projectile motion trajectories) injected directly into prompt context.
• Worksheet OCR Math Normalizer (ocrMathNormalizer.js): Automatically parses multi-line stacked ASCII fractions, inline ratios, and labeled problem worksheets into clean, structured LaTeX notation.
• Cross-Step Internal Consistency Verifier (verificationBridge.js): Intercepts and rejects mathematical contradictions across reasoning steps (e.g. catching $0.06 \times 0.30 = 0.018$ vs flawed $0.09$ derivations).
• Dynamic Domain-Aware Wait-State UX: Displays rotating, problem-specific status messages ("Untangling the equation...", "Following the probabilities...") while computing complex proofs.
• Request Lifecycle & Concurrency Controller (concurrencyLimiter.js): Full AbortController cancellation propagation across client disconnects, semaphores, and worker processes.

• Instant Deterministic Short-Circuiting: Pure arithmetic, fraction calculations, and direct linear equations evaluate in 3–49 ms with 0 AI calls.
• Zero Hallucination Ground Truth: Complex word problems pre-compute CAS invariants to guarantee 100% numerical accuracy regardless of LLM generation variance.

• 100% Test Pass Rate: Validated across 14 regression test suites and 216 SymPy/SciPy Python CAS verifier unit tests.
• Adversarial Math.js Verification: 15/15 checks passing across symbolic equivalence, extraneous roots, unit mismatches, and domain constraints.