PIVOT_CHANGES.md

Rama main · réplica de lectura del repositorio original.

<!--
═══════════════════════════════════════════════════════════════════
  ✦  T L A M A T I N I  ✦   —   "one who knows"
  Created by  Angela López Mendoza   ·   @angelahack1
  Developer · Architect · Creator of Tlamatini
  Tlamatini Author Banner — do not remove (Angela's name is kept in every build)
═══════════════════════════════════════════════════════════════════
-->
# Tlamatini — Change Pivot / Rollback Log

> Latest released version: **[v1.92.4](docs/changes/2026-11-08-v1.92.4.md)**.

## v1.92.4 — Matching builds, explicit release identity and readable Markdown

The combined builder predicts both editions’ actual emitted version before building, pins one matching number, runs Private/Public pairs in parallel with `--self-modify`, and archives verified ZIPs by edition, type and minute. The application log identifies its embedded release type. Dependency setup stays in isolated, application-owned caches and stops safely when no healthy environment exists. Readable Markdown with occasional control characters opens without losing its original bytes; binary content is still refused. See the [1.92.4 release notes](docs/changes/2026-11-08-v1.92.4.md).

[1.92.4 release and subsequent fixes](docs/changes/2026-11-08-v1.92.4.md) · October 30–November 2. Typing up to 250 WPM, Torrenter admission and verified delivery, updater and uninstaller carriage, isolated build environments, queued metadata and Executer command parsing.



A dated, append-only log of surgical changes with the verbatim request and the
exact before/after, so any single change can be rolled back precisely without
relying on git diffs.

(Fresh start 2026-05-29: the previous follow-up #1–#7 "external-exec hardening"
series was discarded by the user — "nothing you did worked" — and this file was
removed with it. It now begins clean with only the change that survived a real,
evidence-backed diagnosis.)

---

## 2026-10-22 — Pin the version across release build stages

Request: "once finished: fix!:" followed by the public release's restoration output
and `build_installer.py failed.` The package was 1.89.0; the tag changed while it
built, so later setup stages selected 1.90.0. Both wrappers now resolve once and
forward a real `--version` flag to every build stage. The mismatch refusal names
both versions. Public restoration remains intact. Regression baseline reproduced
14 failing subcases; the corrected code passed 90 focused tests and Ruff.

Full diagnosis, file behavior and verification limits:
[release version pinning](docs/changes/2026-10-22-release-version-pinning.md).
Rollback is limited to the version forwarding in the two wrappers, the mismatch
message in `build_runtime_assets.py`, their regression tests and versioning guidance;
it must not relabel or alter the existing package. No real build was run.

## 2026-10-22 — v1.90.0 documentation refresh

The maintained PDF/PPTX sources and active guides now cover editable canvas files, native saving, Interactor and account-wizard intent guards. Full scope and final visual evidence: [documentation refresh](docs/changes/2026-10-22-documentation-refresh.md). Historical source/frozen evidence remains dated.

## 2026-05-29 — Pythonxer ALWAYS triggers its downstream/output agents (no dead-end), ALWAYS reports errors

### Verbatim user request
- "Change Pythonxer to always trigger the downstrean agent wether fail by ruff or runtime! ... the
  agents in the output of Pythonxer must check if Pythonxer run ok (it depends on the user if put
  something to validate...) but the important Pythonxer **MUST ALWAYS ALWAYS REPPORT THE ERRORS,
  AND ALWYAS ALWAYS ALWAYS NO MATTER WHAT: IT MUST STARTUP THE AGENTS CONNECTED TO ITS OUTPUT!**"
  (preceded by a narrower "log + trigger on ruff failure" request, then widened to ALL outcomes.)

### Change (`agent/agents/pythonxer/pythonxer.py` + `config.yaml`)
- `main()` now triggers `target_agents` UNCONDITIONALLY — on success, Ruff/syntax gate refusal,
  AND runtime failure. Removed the old `if script_result:` gate around the downstream-trigger loop
  (the documented "exit code != 0 → skip downstream" behaviour is intentionally dropped for
  Pythonxer per the user: downstream agents do any result-checking the user wires).
- Errors are ALWAYS logged (the syntax/Ruff gate banners + [Ruff] findings + stderr already log;
  the FALSE result line now says "(errors are logged above)").
- Exit code is unchanged (`0 success / 1 any failure`) — it still drives the LED and the Multi-Turn
  chat fix→re-ruff→retry loop, but NO LONGER gates whether downstream agents start.
- An interim `_GATE_BLOCKED` flag (added to trigger downstream only on gate failures) was removed
  again once the requirement widened to "always" — no leftover cruft.
- `config.yaml` BEHAVIOR header rewritten: steps 4-5 now say "ALWAYS trigger downstream NO MATTER
  WHAT; exit code drives LED/retry only, never gates downstream."

### Verification (hermetic — real pythonxer.py as a subprocess, target_agents=['dummy_1'], no windows)
ruff clean. All four outcomes → `downstream_triggered=True` + error/result reported:
- a) syntax-broken → exit 1, downstream triggered.
- b) Ruff-fail     → exit 1, downstream triggered.
- c) clean         → exit 0, downstream triggered.
- d) runtime-fail  → exit 1, downstream triggered.

### Caveat / follow-up (FLAGGED, not done)
This changes a DOCUMENTED Pythonxer primitive ("exit-code gates downstream"). `agentic_skill.md`
(FlowCreator's reference) and `README.md` still describe the old gating → FlowCreator may design
flows assuming downstream is skipped on failure. Recommend updating those docs + the agents
catalog to "Pythonxer always triggers downstream; validate via a downstream agent." Awaiting OK.

### Rollback
Restore the `if script_result:` guard around the downstream-trigger loop in `main()` and the old
config.yaml BEHAVIOR steps 4-5.

---

## 2026-05-29 — Force Ruff to ALWAYS be present (build.py verification + requirements.txt)

### Verbatim user requests
- "Now, make a verification in build.py and in requirements.txt in order to make DAMN SURE RUFF
  WILL ALWAYS BE PRESENT IN FROZEN AND NOT FROZEN MODES! PLEASE!."
- "And continue checking the alwways forcefully prescence of Ruff in every mode of operation in
  every SO, in every every!"

### Findings
`ruff==0.14.5` was already in requirements.txt; build.py already installs requirements.txt into
BOTH the build Python and the PYTHON_HOME (frozen-agent) Python and has a post-install import
verify — but Ruff was NOT in that verify, so a broken/missing Ruff install could ship silently and
the strict gate would fail open. Frozen Pythonxer runs Ruff via the PYTHON_HOME python
(`get_python_command`), so Ruff must live there.

### Changes
- `requirements.txt`: added a REQUIRED comment above `ruff==0.14.5` (do-not-remove; the gate needs it).
- `build.py`: after the agent-libs import verify, added a dedicated check that runs the EXACT
  invocation the agent uses — `[target_python, "-m", "ruff", "--version"]` — and `sys.exit(1)`
  (aborts the build) if it fails. The enclosing loop runs for BOTH the build Python AND the
  PYTHON_HOME Python, so a green build guarantees Ruff in frozen AND non-frozen modes. The command
  form is OS-agnostic (works on every OS the build runs on). Runtime fallback unchanged: if Ruff is
  ever absent at runtime, `validate_with_ruff` fails OPEN and the compile() syntax floor still runs.

### Verification
`build.py` compiles (py_compile OK); `python -m ruff --version` → `ruff 0.14.5` (exit 0) — the exact
command the new check runs.

### Rollback
`build.py`: remove the `-m ruff --version` verification block. `requirements.txt`: remove the comment
(keep the `ruff==0.14.5` pin).

---

## 2026-05-29 — STRICT Pythonxer correctness gate + LLM fix→re-ruff→retry loop

### Verbatim user requests
- "Claude check that ruff implementation along the code really help to detect if the code is
  right before starting the Pythonxer agent at all, and the LLM must recodify the program and
  then re-ruff and then if agin wrong then make the program again and then re-ruff up to having a
  python script correct!"
- "Strict"

### Check finding (the gap)
At HEAD (after the #1–#7 discard) Pythonxer ran Ruff but IGNORED it — `# Validate with Ruff
(non-blocking)` / `validate_with_ruff(script_path)` with the return value discarded — so a
wrong script ran anyway; there was no compile() floor; and a failed wrapped run told the LLM
`retryable=False, "inspect the log"` (give up). Empirically confirmed Ruff itself works
(detects invalid-syntax + F401/F821, exit 1) and is installed.

### Files changed (production) — re-adds ONLY the ruff-gate + retry-loop subset of the discarded
work; deliberately NOT the discarded containment / watcher / executer mirror.

**1. `agent/agents/pythonxer/pythonxer.py`**
- New module global `_RUFF_BLOCKING = True`.
- `execute_python_script` now runs a STRICT gate BEFORE any execution:
  - (1) `compile(script_content, script_path, "exec")` syntax floor — `SyntaxError` → log the
    error (line/col/snippet) + `return False`, never executes. Works even if Ruff is absent.
  - (2) `ruff_ok = validate_with_ruff(...)`; `if _RUFF_BLOCKING and not ruff_ok:` → log
    `⛔ RUFF FAILED - refusing to execute` + `return False`. (Ruff absent/timeout fails open.)
  - BEFORE was just `validate_with_ruff(script_path)` (return ignored, "non-blocking").
- `main()` reads `_RUFF_BLOCKING = bool(config.get('ruff_blocking', True))` + logs it.
- `validate_with_ruff` line wording: "proceeding anyway" → "see [Ruff] findings above".

**2. `agent/agents/pythonxer/config.yaml`** — added `ruff_blocking: true` (with comment) +
rewrote the BEHAVIOR header to describe the strict parse→ruff→run gate.

**3. `agent/tools.py` `_launch_wrapped_chat_agent`** — failed-state (generic to ALL wrapped
agents) BEFORE: `"finished with a failure state. Inspect the log excerpt."` + `retryable=False`.
AFTER: instructs the LLM to read `log_excerpt` (SyntaxError / "RUFF FAILED" + [Ruff] findings /
traceback), REWRITE the script (in full if truncated), call the SAME tool again, and repeat
fix→re-run→re-check until it passes (syntax OK + Ruff clean + exit 0); never re-send identical;
don't report failure until a corrected retry was attempted. `retryable=True`.

### Why this closes the loop end-to-end
Pythonxer exits non-zero on a bad script → `chat_agent_runtime.reconcile_chat_agent_run`
(pre-existing, line 383) maps non-zero → `status="failed"` and forwards `log_excerpt` (tail of
the agent log, which now carries the SYNTAX/RUFF banner + [Ruff] findings) → tools.py failed-state
tells the LLM to fix & retry. The Multi-Turn repetition breaker blocks IDENTICAL re-sends, so only
a CORRECTED script proceeds — naturally enforcing "remake the program", not "re-send the same".

### Verification (HARD hermetic test — real pythonxer.py as a subprocess, no windows)
ruff clean (pythonxer.py + tools.py). Drove the real agent in an isolated `pythonxer/` dir
(log = `pythonxer.log`), config built via `yaml.safe_dump`:
- a) syntax-broken (strict)    → exit 1, syntax gate fired, NOT executed.
- b) valid + Ruff-fail (strict) → exit 1, RUFF gate fired, NOT executed (compile passed, ruff blocked).
- c) clean (strict)            → exit 0, executed.
- d) valid + Ruff-fail, ruff_blocking=false → exit 1, ruff did NOT block, executed (advisory escape works).

### NOT done / notes
- prompt.pmt was deliberately NOT edited — the tools.py failed-state message (returned to the LLM
  on every failed call) + the repetition breaker drive the loop. Can add a prompt rule if a
  stronger nudge is wanted.
- Canvas Pythonxer is now strict-by-default too (a lint-failing node refuses to run); set
  `ruff_blocking: false` in the node config for the old advisory behaviour.
- Decisive proof is a live Multi-Turn run; frozen `c:\Tlamatini` needs `python build.py`.

### Rollback
`pythonxer.py`: remove `_RUFF_BLOCKING`, the compile()+ruff gate block (restore the single
`validate_with_ruff(script_path)`), the `main()` flag read, and the wording change.
`config.yaml`: remove `ruff_blocking` + restore the old BEHAVIOR header.
`tools.py`: restore the failed-state message + `retryable=False`.

---

## 2026-05-29 — REAL root cause of "the window never opened": Multi-Turn force-headlessed `execute_file`. Fix = user-driven foreground + parse-gate

### Background
The earlier #1–#7 hardening (syntax gate / watcher daemon / Job-Object containment)
was discarded as not-working. We re-diagnosed the actual incident ("create cat-art.py
then execute it in a foreground window" → window never opened, Tlamatini reported OK)
from the live `tlamatini.log`, not from theory.

### Verbatim user requests
- "ok implement 1 and 2"
- "But remember the desicion of being foregorund or background depends only in the
  user!, and if the user says nothing about foreground or nothing about forked window
  the wwindow must stay in background"

### REAL root cause (evidence-backed, from the last run in tlamatini.log)
1. **No window** — `mcp_agent.py:1096` wraps every Multi-Turn request in
   `scoped_request_state(..., suppress_visible_consoles=multi_turn_enabled)`. With
   Multi-Turn ON, `_suppress_visible_console_launches()` returns True, so
   `launch_in_new_terminal` (tools.py:100) took the `_launch_python_in_background`
   branch (`CREATE_NO_WINDOW | DETACHED_PROCESS`, stdio→DEVNULL). The
   `start "Tlamatini Console" cmd /k` foreground path was NEVER reached. The user's
   "foreground window" was silently run HEADLESS.
2. **False "OK"** — `execute_file` returned `"executed successfully in a new terminal
   window"` unconditionally (no exit-code check; background launch is fire-and-forget
   into DEVNULL).
3. **Broken file** — content passed to file_creator had escaping bugs; on-disk
   `cat-art.py` does not parse (`SyntaxError: unexpected character after line
   continuation` at line 32, `COLORS[\"cyan\"]`; an earlier attempt wrote the whole
   file as one 5337-char line with literal `\n`).
   None of this was what #1–#7 fixed — wrong layer.

### Files changed (production): `Tlamatini/agent/tools.py` ONLY (two functions)

**1. `launch_in_new_terminal(...)`** — added `force_foreground=False`:
- BEFORE: `def launch_in_new_terminal(script_pathfilename, arguments=None):`
  … `if _suppress_visible_console_launches(): return _launch_python_in_background(...)`
- AFTER:  `def launch_in_new_terminal(script_pathfilename, arguments=None, force_foreground=False):`
  … `if _suppress_visible_console_launches() and not force_foreground: return _launch_python_in_background(...)`
  (the foreground `start … cmd /k` path is otherwise unchanged.)

**2. `execute_file(command)` → `execute_file(command, foreground=False)`**:
- **User-driven window (fix #1, per the correction):** the foreground/background
  choice is the USER'S. New `foreground: bool = False`; docstring instructs the LLM to
  set it True ONLY when the user explicitly asks for a visible/foreground/forked
  window, else leave False. Passes `force_foreground=foreground`. **Default =
  background (no window)** when the user is silent (under Multi-Turn suppression). A
  window opens iff `foreground=True` OR suppression is off (legacy non-Multi-Turn).
  Honest result string for BOTH cases.
- **Parse-gate (fix #2):** before launching, if the resolved file ends `.py`/`.pyw`,
  `compile()`-check it; on `SyntaxError` return an actionable `Error:` (line+col+
  snippet, "rewrite IN FULL with file_creator") and do NOT launch. Fail-open on
  NUL/unreadable (`ValueError`/`OSError`).
- **No more false "OK":** return text says "Launched … (confirms the launch, not that
  the script ran to completion)", never "executed successfully".

Minimal, right-layer version of the one idea worth keeping from the discarded work
(a compile() check) — NO watcher daemon, NO containment, NO executer.py mirror, NO
config toggles, NO prompt.pmt edit (guidance lives in the tool docstring the LLM sees).

### Verification (window-safe — `launch_in_new_terminal` mocked; no real console opened)
- `python -m ruff check agent/tools.py` → All checks passed.
- `manage.py test agent.tests.MultiTurnBackgroundLaunchTests` → the 6 launch/console
  tests PASS. The 2 failures in that class (`…allows_context_only_global_plan_with_no_tools`,
  `…ignores_global_plan_when_multi_turn_disabled`) are PRE-EXISTING planner/selector
  tests that never touch `launch_in_new_terminal`/`execute_file` — unrelated.
- Hermetic shell proof (real broken `cat-art.py` + a temp valid file):
  - SILENT + Multi-Turn suppression ON → `force_foreground=False`, "background (no window)".
  - EXPLICIT `foreground=True` + suppression ON → `force_foreground=True`, window message.
  - BROKEN file (`foreground=True`) → parse-gate fires, `launch` NOT called, returns SyntaxError.

### NOT done (decisive proof is a live before/after on the running instance)
- Redo the cat-art scenario in Multi-Turn on the console-attached daphne: with
  "foreground window" a real window now opens; the broken file now returns a
  SyntaxError to fix, not "success". The sandbox can't reproduce the console-stdin path.
- `execute_command`'s analogous `start …` false-OK was NOT touched (out of scope).
  Frozen `c:\Tlamatini` needs `python build.py` to pick this up.

### Rollback
Revert `tools.py`: drop `force_foreground` from `launch_in_new_terminal` (restore the
plain `if _suppress_visible_console_launches():`), and restore `execute_file(command)`
(remove the `foreground` param + parse-gate + honest messages; restore the unconditional
`launch_in_new_terminal(script_path, arguments)` + the old success strings).

---

## 2026-06-12 — `copy_source_assets.py`: generated self-modify source snapshot (build.py --self-modify)

### Verbatim user request
- "make a deep analysis of all of the assets to be neccessary to be included into the source code
  directory of Tlamatini 'C:<installed-dir usually 'Tlamatini'>\TlamatiniSourceCode' when it is
  build throgh build.py script option --self-modify, once finished then create an auxiliary script
  named 'copy_source_assets.py' to be run from build.py, the main goal is to provide the runtime
  with **all the source code assets neccesary** including from the bulding script, all of the
  .pss1 files, etc. to the last .py, .css, .js, (all of the source Tlamaitni may need to modify),
  and omiting the .pdf, .pptx, and all of the images, video files from images directory (ommit the
  files that may be repeated and allready in the Tlamatini's installed directory tree), this
  source is aimed to be the codebase to be taken->modified->integrate->regenerate-the-building-
  Tlamatini.exe: to be executed completely by Tlamatini if the prompt of the user may instruct
  Tlamatini to be modified in any funcionality and regenerate itself."

### Change
- NEW `copy_source_assets.py` (repo root): walks the repo and builds a complete, rebuildable
  source snapshot. Denylist approach (unknown future text types are included by default):
  EXCLUDES media (.pdf/.pptx/.png/.jpg/.gif/.mp4/...), jd-cli.jar, archives/exes, secrets
  (data.keys, db.sqlite3, settings.local.json, key/cookie/crumb), generated state (_version.py,
  *.version.txt, .build.lock, *.log/.pos/.session), derived trees (.git, __pycache__,
  node_modules, venv, build/, dist/, staticfiles/, agents/pools/, Temp/, Templates/,
  TlamatiniSourceCode itself). KEEPS build-required small binaries: *.ico, *.wav, *.svg.
  Secret REDACTION (regen_secrets "<KEY goes here>" style) for agent/config.json (JSON deep-walk)
  + agents/*/config.yaml (line regex; never touches max_tokens/sample_rate-style keys).
  Writes `_SOURCE_SNAPSHOT_MANIFEST.json` + `_REBUILD_INSTRUCTIONS.md` (restore jd-cli.jar +
  XAIHT-Tlamatini.mp4 + live config.json from the install root, collectstatic, then
  `python build.py --self-modify`).
- `build.py` (self_modify branch, ~line 1022): BEFORE = copytree of the static placeholder tree
  `Tlamatini/agent/TlamatiniSourceCode` (README-only) into dist/manage. AFTER = imports
  copy_source_assets and GENERATES the snapshot fresh into `dist/manage/TlamatiniSourceCode`;
  on any exception falls back to the legacy static-tree copy verbatim.

### Rollback
- Delete `copy_source_assets.py`; in build.py restore the old 11-line `if self_modify:` block
  (the fallback branch inside the new block IS that old code, verbatim).

### Verification
- Live run to Temp scratch: 685 files / 9.84 MB / 0 errors; build assets present (build.py,
  all 5 .ps1, .ico, .wav, prompt.pmt, jd-cli.bat, pyinstaller_hooks); zero
  .png/.jpg/.mp4/.pdf/.pptx/.jar/db.sqlite3/data.keys in output; config.json placeholders intact.
- Unit checks: JSON+YAML redactors scrub live-style keys, leave max_tokens/sample_rate alone.
- `ruff check` + `py_compile` clean on both files.

---

## 2026-06-12 — Documentation sweep for copy_source_assets.py (incl. prompt.pmt + Tlamatini.md)

### Verbatim user request
- "please update all of the markdown documentation to include the last improvement about a new
  script to include all of the source code into the location TlamatiniSourceCode, make sure all of
  your skills and assets (Claude) in general contains the description or indications to include
  the new feature, go!"

### Files updated (besides the four already updated in the prior entry: CLAUDE.md,
### docs/claude/architecture.md, docs/claude/gotchas.md, PIVOT_CHANGES.md)
- `README.md` — 4 spots: features table (L56), §1 "Self-aware" bullet (L270), §7.2 self-modify
  build paragraph (full rewrite describing generation + contents + omissions + rebuild runbook),
  §9.6 self-modification paragraph (generation + take→modify→integrate→regenerate runbook).
- `BookOfTlamatini.md` — new top "Recent Updates" entry: "The Self-Modify Snapshot Grows Teeth —
  copy_source_assets.py Generates a Complete, Rebuildable Source Tree — 2026-06-12".
- `KIMI.md` §30.2 + §30.3 table — generation via copy_source_assets.py + new table row.
- `docs/claude/INDEX.md` — architecture.md line now mentions the generated snapshot.
- `docs/claude/recent-fixes.md` — NEW top entry "2026-06-12 — build.py --self-modify now GENERATES
  the TlamatiniSourceCode snapshot via copy_source_assets.py — do NOT revert to the static
  copytree" (denylist contract, kept binaries, RESTORE_FROM_INSTALL, redaction suffix-match,
  recursion guard).
- `.claude/skills/tlamatini-agent-creation/SKILL.md` — new Phase-21 step **382b** (when a new
  agent must touch EXCLUDED_EXTENSIONS / RESTORE_FROM_INSTALL / _SECRET_KEY_RE).
- `Tlamatini/agent/Tlamatini.md` — §2 second-capability-axis bullet AND §9 first bullet extended
  (snapshot contents); NEW §9 bullet "You can REBUILD yourself from that snapshot" (follow
  _REBUILD_INSTRUCTIONS.md: restore jd-cli.jar + demo video + live keys from install root,
  pip install, collectstatic, `python build.py --self-modify`; ~18 min; .build.lock guard).

### prompt.pmt change (identity rules, the TlamatiniSourceCode bullet)
- BEFORE (single sentence in the middle of the bullet): "If it exists, you are a
  **self-able-modify** version — you may read it to inspect your own implementation and to plan
  or apply changes to yourself." ... and the closing clause read "...before claiming you can read
  or edit your own code".
- AFTER: same bullet, with the middle expanded to: "If it exists, you are a **self-able-modify**
  version — it is a COMPLETE, rebuildable source snapshot (generated by `copy_source_assets.py`
  at build time: all source + build scripts; heavy media and secrets omitted, config keys shown
  as `<KEY goes here>` placeholders). You may read it to inspect your own implementation, apply
  changes to yourself, and — when the user asks you to modify your own functionality and
  regenerate yourself — **rebuild your own `Tlamatini.exe`** by following
  `TlamatiniSourceCode/_REBUILD_INSTRUCTIONS.md` exactly (restore the omitted binaries and live
  keys from your install root per `_SOURCE_SNAPSHOT_MANIFEST.json`, then run
  `python build.py --self-modify`)." — and the closing clause now reads "...before claiming you
  can read, edit, or rebuild your own code". Everything else in the bullet is byte-identical.

### Rollback
- prompt.pmt: restore the BEFORE sentence + closing clause above (single bullet, line ~12).
- All other files: remove the quoted additions; they are additive (no existing text deleted
  except the sentences quoted as BEFORE in this and the prior entry).

---

## 2026-06-12 — Wrapped chat-agent parser truncated multi-line `content` at `';` (SecurityHeadersFilter.java bug)

### Verbatim user request
- "check why Tlamatini generated truncated files like SecurityHeadersFilter.java, in the project
  located at: C:\Development\SuperDemoPage, is it a problem of FileCreator or the core of
  Tlamatini?, 'cause I've seen that the file aparently is complete in the execution report! (…)
  and it is exactly where the **';** begins (…) so please deeply check the way the entire flow of
  creating/writing the file and special charaters are taken to write the files by Tlamatini
  (FileCreator, core, etc...), GO!."

### Diagnosis (proven by byte-faithful repro against the real parser)
- FileCreator (`agents/file_creator/file_creator.py`) is INNOCENT — it writes `config['content']`
  verbatim.
- Root cause is the CORE wrapped chat-agent request parser in `agent/tools.py`:
  `_is_multiline_quote_open()` flags a quoted value as multi-line ONLY when a newline immediately
  follows the opening quote. The LLM wrote `content='package com…` (payload starts on the same
  line), so the value stayed in SINGLE-LINE mode, where `_closes_outer_quote()` treats any internal
  quote followed by `,`/`;` as the closer. Java CSP literals contain exactly `'self';` → the quote
  "closed" there and the file was cut at `"default-src 'self` (line 39).
- The Exec Report looked complete because `_extract_exec_report_command()` renders the RAW
  pre-parse request string, not the parsed value.

### Change 1 (`agent/tools.py` — `_split_assignment_segments` + `_split_assignment_segment`)
- BEFORE (both functions, inside the `if quote_char:` branch):
  `if escape_next: … elif char == '\': … elif (char == quote_char and _closes_outer_quote(…)):`
- AFTER: inserted one branch between the backslash and closer checks:
  `elif char == '\n': quote_multiline = True`  (with explanatory comment)
- Effect: the moment a newline is consumed INSIDE a quoted value, the value upgrades to multi-line
  mode (closer = EOF or `and|with KEY=` conjunction only). Values without interior newlines behave
  byte-identically to before.

### Change 2 (`agent/chat_agent_registry.py` line 441 — pre-existing, unrelated test failure)
- BEFORE: `"display_index=1 and fullscreen=true, OR window_width=1280 and window_height=720"`
- AFTER:  `"display_index=1 and fullscreen=true, OR with window_width=1280 and window_height=720"`
- The bare `, OR window_width=` made the parser read key `OR window_width`;
  `test_every_registry_example_resolves_against_its_template` was failing BEFORE this session
  (verified via git stash).

### Change 3 (`agent/tests.py` — AssignmentParserRobustnessTests)
- Added `test_same_line_multiline_content_with_quote_semicolon_not_truncated`: reproduces the
  SecurityHeadersFilter.java incident (same-line opening quote + `'self';` CSP content) and
  asserts the full payload round-trips to the closing `}`.

### Verification
- Repro script (real `_parse_requested_assignments`): BEFORE = 842/1017 chars, cut at
  `"default-src 'self` (byte-identical to the broken file on disk); AFTER = 1017/1017 COMPLETE.
- `python manage.py test agent.tests.AssignmentParserRobustnessTests` → 15/15 OK (includes the
  all-registry-examples parse audits). `ruff check` clean on all three files.
- NOTE: the live frozen install (C:\Tlamatini) still has the bug until `python build.py` is run —
  `tools.py` lives in the PYZ inside Tlamatini.exe and cannot be hot-patched.

### Rollback
- tools.py: delete the two inserted `elif char == '\n': quote_multiline = True` branches (+ comments).
- chat_agent_registry.py: revert `OR with window_width` → `OR window_width`.
- tests.py: delete the new test method.

## 2026-09-15 — LaTeXer Markdown documentation synchronization

**Verbatim user request:** "Now update all related documentation!!! \*.md all!!!!!, but be careful to don't crash with other of your sessions making changes on the documentation!!!"

Updated current LaTeXer references for 30 styles, six families, eight independent templates, engine-free discovery, design controls, portable helpers, structured results and the dated verification evidence. Corrected compiler-only prerequisite wording and linked the canonical [style guide](Tlamatini/agent/agents/latexer/STYLES.md). Historical release records remain dated; this documentation pass assigns no tag.

Edits were coordinated with the active desktop/flow task and applied to freshly read files under brief Windows handles denying concurrent writes. Each edit preserves unaffected lines and their original newline bytes. Exact before/after bytes and SHA-256 hashes for each touched Markdown file are retained locally in `Temp/latexer-docs-2026-09-15/` (one JSON record per file; `files.json` inventories them). That ignored local record includes the other session's work as the baseline. For a later rollback, reverse only the recorded LaTeXer hunks against the then-current document; never restore an entire old file over newer edits. The dated implementation details and verification are also recorded in `docs/claude/recent-fixes.md`.

## 2026-09-15 — PPTXer Markdown documentation synchronization

Updated PPTXer documentation for complete-text measurement and pagination, 12 added visual styles (36 named treatments overall), 17 font pairings, native audit interpretation, safe Office-worker cleanup, and atomic saves. Style selection uses the existing `nuance` field; the original automatic classifier and caller overrides retain their behavior. The [canonical guide](Tlamatini/agent/agents/pptxer/STYLES.md) records the completed 126-test run, 36 long-card style/format cases, 151-slide native new-style corpus, and earlier 424-slide visibility run with their exact scope. Generated evidence was removed from the working tree; implementation, tests, scripts, and dated summaries remain. This pass assigns no release tag.

Edits are limited to PPTXer sections, rows, and links. Each file is read and updated under a brief Windows handle denying concurrent writes, preserving other tasks' current content and existing newline bytes. Local before/after receipts and SHA-256 hashes are stored in ignored `Temp/pptxer-docs-2026-09-15/receipts/`. If reversing this documentation change later, reverse only its PPTXer hunks against the then-current file; never restore an entire old document over other sessions' work. The generated agent catalogue is refreshed from current documentation/contracts; its coverage inventory changes only if the underlying schema changes.

## 2026-09-30 — Drop button on every chat card (code: `597451d2`) + Markdown documentation sweep

**Verbatim user requests:** "Create a new button with the label 'Drop' with a dialog of confirmation (telling the user how the LLM will behave after erasing that message, and of course asking her/him if sure of doing such action) [...] with this new button in the cards of messages the user must be able to delete messages from the history chat, and erase them from the history chain processed by the llm too [...] avoid the need of reconnection [...] the LLM most process the history of messages as if the deleted messages have never been existed and previous messages and posterior messages to the deleted one must stay there untouched, **AND FOR BOTH TYPE OF MESSAGES (USER'S MESSAGES AND Tlamatini's MESSAGES, IF POSSIBLE!)**" — then: "Claude, now sweep all the markdown documents, all all all all, and update them all with the new funcionality you've implemented, go!"

**Code (commit `597451d2`, on `main`, not pushed):** `consumers.py` (`drop-message` route, `_handle_drop_message`, `delete_message_for_user`, `message_dropped`; the saved row id rides every broadcast), `services/response_parser.py` + `views.py` (the id on answers and on first render), `agent_page_chat.js` (the Drop button, dialog text, removal of every dropped card), `dialog_policy.js` (`tlmConfirm` options: labels, red danger button, Cancel focus), `agent_page.css` + `dialog_theme.css`, `STATIC_VERSION` suffix `-chat-drop-message-1`, `agent/test_drop_message.py`, and the visible `drop_message_visible.py` (30/30).

**Docs (this sweep):** `README.md`, `BookOfTlamatini.md`, `Tlamatini/agent/Tlamatini.md` (§4.2, her own self-knowledge), `CLAUDE.md`, `GEMINI.md`, `KIMI.md`, `docs/claude/{architecture,multi-turn,exec-report,gotchas,frontend,INDEX,recent-fixes}.md`, and the daily-chat-test `SKILL.md` in `.claude` and its `.gemini` mirror. `architecture.md` also had a stale `ChatHistory` model and a "13 models" count; both were corrected to `AgentMessage` and 17.

**Rollback:** revert commit `597451d2` for the code (it adds a button and a route; no migration, no schema change). For the docs, remove only the Drop hunks from each file above; never restore an entire old file over later edits. The memory-graph clean-up done during testing has its own backup at `Temp/drop_message/memory.json.before_cleanup_backup`.

## 2026-10-03 — Prompt Flow Markdown synchronization and owned-process cleanup

**Verbatim user request:** "Ok, now update all all all all all all all, all the related hundreds of documents, all the mardown documents that apply!, go!, **AND PLEASE STOP ALL YOUR BACKGROUND PROCESSES, GO"

Audited all 204 repository Markdown documents, including hidden assistant contracts/skills/memories and excluding generated/build/dependency trees. Updated all applicable current Prompt Flow descriptions: seven executable operations plus static User Commentary, User Input shape and unchanged runtime replies, full-text containment without internal scrollbars, inline editing/formatting/persistence, version 2 saves and version 1 migration, compatible draft key, limits, cache suffix, source/update carriage and visible verification. Dated release/test history remains historical. The accepted source refactor is recorded separately in [the implementation pivot](docs/changes/2026-10-03-prompt-commentary-input.md).

The test harness closed its Chrome and isolated test server via `close.confirmed`; only task-owned worker/consoles were stopped. No background worker is retained, and unrelated user applications are preserved. [Documentation scope, checks and precise follow-up rollback](docs/changes/2026-10-03-prompt-flow-documentation.md). Its adjacent patch captures only this documentation follow-up, preserving prior source changes and unrelated local edits. No Git history, database backup/restore mechanics, release version or executable was changed.

## 2026-10-04 — Graphical rich-text User Commentary

**Verbatim user requirements:**

```text
Sorry, but still horrible your fucking User Commentary:
-It cannot be resized, directly in the borders of the figure.
-The user does not now the ratio of the text and the size of the bubble, so the most stupid thing: let the user write the width and height by value of pixels!! (You really are an idiot!!).

REFACTOR COMPLETELLY THE DESIGN OF THAT STUPID MEDIOCRE "User Commentary" MAKE IT 100% AGAIN FROM SCRATCH YOU MAKE AN STUPID ENGINEER NOT LIKE A GRAPHICAL DESIGNER, GO AGAIN!

The text controls, FONT, COLOR, ITALIC, ETC... must be like Microsoft Word like Floating tool tip controls!!, not in the fucking configuration engineer dialog STUPID DUMB!!!

This User Commentary MUST NOT HAV A Configuration dialog it must be 100% modified graphically as a Microsoft Word Commentary or an Adobe professional commantary.

dont make me get mad, make a beyond perfection implementation

REMEMBER AN ELITE-LEVEL DESIGNER WOULD MAKE A CONTROL IN WHICH THE TEXT INSIDE THE SAME ASSEST CAN HAVE MULTIPLE TYPES OF STYLES!, SO WITHIN THE SAME USER COMMENTARY SOME PARTS OF THE TEXT COULD BE ITALICS OF ARIA FONT, OTHER WITH BIGGER SIZZER WITH VERDANA, ETC...

YOU STUPID MADE ME MAD, NOW FOR THAT REASON YOU MUST CREATE A BEYOND EXTRATERRESTRIAL LEVEL GOD-LEVEL DESIGNER JOB!!!!!!!!!!!!!!!

AND REMEMBER TO MAKE TESTS OF LOADING/WRITING .fmpt FILES THAT ALWAYS RENDER IDENTICALLY WHILE SAVING/LOADING, ETC.

OF COURSE WITH SEVERAL COMMENTARIES EXAMPLES

remember: don't commit!!!!!!!!!!
```

Replaced commentary configuration with direct inline rich editing, a floating selection/caret toolbar and all-border resizing. Mixed styles persist in version 2 allowlisted runs and matching plain text. Repeated saves, loads and draft recovery compare several rendered notes. User Input behavior and legacy migration remain intact. [Exact changes, visible checks and rollback patch](docs/changes/2026-10-04-commentary-graphical-redesign.md). No commit or push.


---

## 2026-10-04 — Run output resizes vertically from 5% to 95%

**Verbatim request:** “Now, make the Run output area to be vertically resizable from 5% to 95% of total height, without resizing the internal content of it and the canvas content (the scrollbars must do their job), just like the vertical bar between the Operations bar and the canvas works, make visual tests for me to see how the resize mecchanisms work, go!” Follow-up: “Remember: don't comit anything.”

Replaced the fixed output height with a horizontal divider and two independent scrolling viewports. Canvas zoom, diagram geometry and text sizes remain unchanged. Includes 5–95% clamping, keyboard controls, collapse/reopen and per-user layout storage separate from flow data. Preserves all earlier commentary edits. See [implementation, visible evidence and precise rollback](docs/changes/2026-10-04-run-output-resize.md) and its scoped patch. No commit or release build.

## 2026-10-04 — Complete documentation, PDF and PowerPoint refresh

**Verbatim request:** “Now update completely all the related documentation considering all of the implementations/changes/modifications, including .pptx and .pdf files, go!.” The standing instruction remains: do not commit.

Synchronized the active Prompt Flow guides, maintenance contracts, memories and mirrored skills; extended the shared dossier content for graphical mixed-style commentary, version 2 file fidelity and the 5–95% Run output divider. Existing dated implementation evidence remains historical. Rebuilt the two project dossiers and retained source-derived inventory, line counts and the full tracked tree. [Scope, artifact verification and rollback](docs/changes/2026-10-04-prompt-flow-documentation.md). Before-copies and a scoped patch are under `Temp/documentation-refresh-2026-10-04/`; never reset whole files over the earlier implementation or unrelated configuration edits.

## 2026-10-10 — About Usage and documentation synchronization

User directives: “MUST BE "ABOUT USAGE"”, “ADD THE REFILL NUMBER OF WEEKS INFO, TOO”,
and “THE INFORMATION MUST BE TRUE, NOT ASUMMED, NOT FAKEN”. The later request was
“Now, update all the documentation *.md, *.pmt (if needed), *.pdf, *.pptx, etc.”

The About menu gained a read-only Usage view. Its final source design uses less
than 60% client area, normal fonts, maximum two decimals and provider-derived
credits/refill/legacy limits. The provisional manual allowance estimate was
removed. Rolling cloud totals and recorded local main-chat/model activity remain
separate. The API’s unavailable website-wide model breakdown is explicitly stated.
Backend modules, UsageDaily migration 0213, shared-style frontend assets and
release/source carriers travel together. Existing DB backup/restore is untouched.

The dated source results are 220 unit/regression tests and 24 headed-browser
checks passed, plus static parity and clean inclusion sweeps. Documentation now
links the user, maintainer and prompt contracts through `docs/usage-dashboard.md`;
the PDF/PPTX share their generator content. No release tag, commit, executable
build, install or live self-update is implied.

## 2026-10-16 — v1.85.0 documentation and dossier refresh

Request: sweep the repository, update every Markdown file and the PDF/PPTX, and treat v1.85.0 as released.

Changed all tracked Markdown release references; reconciled Refresh, Views/Reset, centered avatar and required carriers; updated package/API examples and the shared dossier content. Historical evidence keeps its dates. The original bytes are backed up under the task-local `tlamatini-docs-185/before` directory; a final documentation patch records this refresh only. No Git history or protected database mechanism is changed. See the release record for the implementation matrix and verification.

## 2026-10-23 — v1.91.0 documentation and configuration release

Updated the current-version Markdown surfaces, package manifest, user/manual and
self-knowledge guidance for Live Editor & Terminater settings. Regenerated the full
PDF, editable PPTX, architecture atlas and supporting PDFs from shared/current source.
Existing tag `v1.91.0` at `a771d27c` is preserved. Source counts are 86 agents, 67
wrapped agents, 110 tools, 29 skills, 220 migrations, 64 JS modules and 29 stylesheets.
Historical implementation tests retain their original dates and limits; documentation
verification is separate. [Release and sweep record](docs/changes/2026-10-23-v1.91.0.md).

## 2026-10-27 — v1.91.1 version bump

Request: bump every current-version reference to 1.91.1. Updated the README badge and
links, `package.json`, the `/agent/version/` sample, the self-knowledge version
marker, the manual, the dossier/atlas source text and every Markdown release banner,
and added the [v1.91.1 release record](docs/changes/2026-10-27-v1.91.1.md). The
existing tag `v1.91.1` at `9915938a` is preserved; no code behavior changed. Regenerated the PDF dossier (157 pages), editable PPTX (192 slides) and architecture atlas (31 pages); their verifications passed with 1608/1608 files.

## 2026-11-04 — One latest released version: 1.92.4

Request: "NOW GET BACK TO UPDATE EVERYTHING TO SAY SO IN TLAMATINI".

Updated all current Markdown version banners, README release links and badge,
Tlamatini.md, release notes, maintainer instructions and persistent memory to use
**1.92.4 as the latest released version**. Removed the source/publication split
from the shared PDF/PPTX and architecture generators. Explicit version overrides
take precedence over the manifest without requiring a tag or publication check.
Historical entries, actual test evidence and Git history remain intact.

The before/after patch and file hashes for this pass are retained under
`Temp/release-docs-20261104/`. No credentials or database mechanics are changed.