pycforge 1.3.43__tar.gz → 1.3.45__tar.gz

pycforge-1.3.45/CURRENT_STATE.md

@@ -0,0 +1,1340 @@
+# PyCForge 1.3.44 — Crucible release documentation
+
+- Package the complete application as 1.3.44, including metadata, startup,
+  workspace and About versions, and every generated HTML Help footer.
+- Publish the corrected README with its existing section order and examples,
+  current Typed conversion coverage, 29 Help pages and recent conversion fixes.
+- Retain exactly four external images: the PyCForge banner, two UI screenshots,
+  and the approved Crucible engine banner directly below the bug tracker.
+- Preserve the conversion engine, dependencies, icons and practical HTML Help.
+- See PyCForge-1.3.44-Verification.txt for the exact release checks and hashes.
+
+# PyCForge 1.3.43 — Immutable Typed record locals
+
+- Support fresh record aliases, exact initialized local class annotations,
+  chained assignment and flat literal unpacking with ordered evaluation.
+- Preserve nominal types and immutable C value copies; reject mutation,
+  identity observations, redeclaration and collection aliases.
+- Retain explicit historical profiles and replay local declaration proofs.
+- Align the Classes & Functions copy action to the left title-bar slot.
+- Extend practical HTML Help without development-cycle status.
+- Refresh the existing README's conversion coverage and recent bug fixes;
+  retain its section order, feature focus, examples and contact information.
+- Introduce the Crucible engine banner below the bug tracker. Keep exactly
+  four external image URLs: the main banner, two UI screenshots and Crucible.
+- Rebuild the same 1.3.43 wheel and source archive for the user's own upload.
+- See specifications/record_locals_1_3_43.md and
+  PyCForge-1.3.43-Verification.txt for scope and verification.
+
+# PyCForge 1.3.42 — Structured immutable Typed records
+
+- Read fields directly from constructors, factory results, nested records and
+  constant-indexed record collection elements; preserve evaluation order.
+- Support exact nominal nested record fields with bounded acyclic inline
+  layouts, and fixed local homogeneous record lists/tuples with ordered loops.
+- Replay source/collection evidence before emission; validate nested C types,
+  dependency order and const propagation. Keep earlier explicit profiles.
+- Fix private-field name-mangling conversion and reject late imports used by
+  nested record annotations before they are bound in Python.
+- Add complete executable HTML examples and synchronize existing Help limits.
+  README.md remains byte-for-byte unchanged; no UI or Runtime behavior change.
+- See specifications/record_structures_1_3_42.md and
+  PyCForge-1.3.42-Verification.txt for scope, checks and remaining limits.
+
+# PyCForge 1.3.41 — Typed record constructor expressions
+
+- Support direct record construction in returns and positional function
+  arguments, including branches, nested calls and imported class aliases.
+- Preserve exact nominal types and scalar field layouts. Stage arguments once
+  from left to right and return automatic struct values without heap storage.
+- Authenticate constructor expression evidence against the source and retain
+  explicit historical profiles with their previous constructor limits.
+- Add a complete reflection-and-distance example to HTML Help and update the
+  multi-module and separate C caller examples. Describe supported usage and
+  practical limits without development-cycle commentary.
+- Leave README.md byte-for-byte unchanged, including its version heading and
+  three approved image URLs, while conversion upgrades continue.
+- See specifications/record_expressions_1_3_41.md and
+  PyCForge-1.3.41-Verification.txt for technical scope and verification.
+
+# PyCForge 1.3.40 — Typed records across supplied modules
+
+- Import immutable record classes directly from their defining supplied module,
+  with optional aliases. Pass and return exact record types through imported
+  functions; allow record-only companion modules.
+- Preserve nominal class identity, scalar field layouts, value-copy C structs
+  and separate module exports. Authenticate imported aliases against retained
+  source and validate cross-module C types through declared dependencies.
+- Promote typed-record-modules-v1.3 / c-renderer-v1.3. Explicit historical
+  profiles retain their previous limits; Runtime conversion is unchanged.
+- Add an executable three-module geometry example to HTML Help, including
+  import rules, factory results, nominal typing and remaining call limits.
+  Restore the current-version footer on five existing Runtime Help pages.
+- Update only the README version and affected conversion coverage. Retain its
+  established prose, code examples, contact, bug tracker and exact three approved
+  image URLs. The existing screenshots remain accurately labeled 1.3.39.
+- Package no screenshots or design images; preserve the required app icons.
+- See specifications/record_modules_1_3_40.md and
+  PyCForge-1.3.40-Verification.txt for scope and verification.
+
+# PyCForge 1.3.39 — Typed record parameters and returns
+
+- Add nominal immutable record parameters, factory results, forwarding and
+  returns in Typed mode. Preserve exact field types and positional evaluation
+  order; reject mutation, mismatched classes and unsafe value uses.
+- Generate C structs passed and returned by value without heap allocation.
+  Include exact generated type names and record layouts in module export metadata.
+- Promote typed-record-values-v1.2 / c-renderer-v1.2 while preserving explicit
+  historical profiles. Runtime keeps its 1.3.38 conversion contract.
+- Expand executable HTML Help with complete Python and separate C caller
+  examples, copy semantics and clear module/call limits. Repair the Help catalog's
+  Runtime strings keyword count so all documentation pages can load.
+- Refresh the established README for 1.3.39 with the approved banner and two
+  exact Cloudinary screenshot URLs, current conversion coverage, and the five
+  confirmed 1.3.32 audit fixes above the retained contact details. Keep code
+  examples and application icon files unchanged; add no other README links.
+- Exclude screenshots and design images from release archives; retain only
+  required application icons and enforce this in distribution verification.
+- See specifications/typed_record_boundaries_1_3_39.md and
+  PyCForge-1.3.39-Verification.txt for scope and verification.
+
+# PyCForge 1.3.38 — Runtime text layout and normal editor scrollbars
+
+- Add Runtime center, ljust, rjust, zfill and expandtabs with Unicode character
+  widths, bound/expanded calls, argument validation, and bounded output work.
+- Default both Python panes to ordinary vertical/horizontal scrollbars. Retain
+  diagnostic, Find and ForgeLens navigation without the overlapping marker rail.
+- Fit gutters to the text viewport; correct orientation-specific handle sizing,
+  scroll-area corner painting and editor edge clipping in Python and Generated C.
+- Extend executable HTML Help; preserve README, dependencies and theme artwork.
+- See PyCForge-1.3.38-Verification.txt and specifications/text_layout_scrollbars_1_3_38.md.
+
+# PyCForge 1.3.37 — Editor feedback and Save As corrections
+
+- Show the saved filename in tabs, Source Bundle rows, source headers and window titles.
+  Preserve explicit module/logical identities and imports. Complete the visible save
+  projection before reporting success, including when snapshot delivery is delayed.
+- Put call signatures in the existing status strip; retain clickable completion lists.
+  Retire hints when their editor context changes without replacing newer status feedback.
+- Highlight function/class names without repainting def/class. Respect lexical string
+  and comment boundaries, multiline state resets and UTF-16 positions.
+- Distinguish source edits from syntax-format refreshes. Preserve authenticated fold
+  arrows, collapsed functions and source markers across format-only updates.
+- Update HTML workspace Help. Keep README, converter engines, matte theme and icons.
+- See PyCForge-1.3.37-Verification.txt and specifications/editor_feedback_1_3_37.md.
+
+# PyCForge 1.3.36 — Separate Typed C module exports
+
+- Export a fresh Typed conversion as one C source/header pair per module,
+  shared type declarations, and a machine-readable C ABI manifest in a ZIP.
+- Preserve validated function bodies and existing generated symbols. Resolve
+  helper dependencies per translation unit; keep support helpers internal.
+  Check portable filenames, C11 significant symbol prefixes and complete emission ranges.
+- Add File → Export C Modules in the existing matte custom chooser. Build archives
+  off the UI thread and atomically publish only while the exact Typed result is fresh.
+  Pending text/identity edits immediately retire export authority. Existing Save C,
+  ForgeLens and Compile continue to use the unchanged single-file result.
+- Document C parameter declarations, file status arguments and ownership.
+  HTML Help includes an executable API export and separate C caller; README unchanged.
+- Runtime exports still require a shared-context ABI design. No new Python syntax,
+  dependencies, stable cross-release binary ABI, or automatic record boundaries are claimed.
+- See PyCForge-1.3.36-Verification.txt and specifications/module_exports_1_3_36.md.
+
+# PyCForge 1.3.35 — Runtime text parsing coverage
+
+- Add rsplit, splitlines, partition/rpartition, and exact prefix/suffix removal.
+  Support Unicode whitespace/line boundaries, embedded NUL, bound methods,
+  keyword forms where Python permits them, and supplied-module parser helpers.
+- Charge text scanning/comparison work to the existing execution budget;
+  preserve terminal allocation/work failure semantics and arena ownership.
+- Extend HTML Help with executable configuration and filename parsing examples.
+  Keep the matte UI, README, dependency list and Typed contracts unchanged.
+- Verification details and platform limits: PyCForge-1.3.35-Verification.txt.
+
+# PyCForge 1.3.34 — Runtime text update modes
+
+- Add r+, w+, a+, and x+ UTF-8 file workflows in Runtime conversion.
+  Require successful seek between reads and writes. Append-update begins at
+  EOF and preserves append semantics; exclusive-update preserves existing files.
+- Reject nonzero read-derived bookmark writes before changing data.
+  Such bookmarks still replay reads. Tell/flush cannot bypass direction checks.
+- Keep budgets cumulative, avoid input-stream fflush, and close streams on
+  positioning failures. Internal file layout changed: regenerate C/rebuild callers.
+- Add HTML Help with three runnable examples, mode comparison and precise limits.
+  README, matte UI, dependencies and Typed conversion contracts stay unchanged.
+- Verification details and platform limits: PyCForge-1.3.34-Verification.txt.
+
+# PyCForge 1.3.33 — Universal matte interface and harpy eagle branding
+
+- Apply brighter graphite surfaces and solid matte buttons across the workspace,
+  menus, dialogs, reports, scan panels, Help, and Ting viewers. Hover, focus,
+  pressed, checked, disabled, and semantic feedback remain distinct.
+- Introduce the gray harpy eagle and steel-blue C lettering. Rebuild the 56-icon
+  PNG catalogue at nine sizes, including simplified eagle artwork for small UI
+  placements. No SVG assets are shipped.
+- Separate dialog resizing from maximizing. Compact prompts/settings remain fixed;
+  command and list dialogs resize where useful; large viewers explicitly offer
+  maximize/restore beside Close on the right. Move the Classes & Functions Copy
+  action into the right title-bar toolbar.
+- Keep About's system information inside compact displays and make the exact
+  registry fingerprint selectable in a read-only field. Own deferred dialog-focus
+  restoration with a timer that ends with the dialog. Fixed startup progress
+  still refits longer stage/failure messages, including larger UI fonts.
+- Update HTML Help with appearance and dialog-control guidance. README.md and
+  conversion/scan engines remain byte-for-byte unchanged from 1.3.32.
+- Verification details and platform limits: PyCForge-1.3.33-Verification.txt.
+
+# PyCForge 1.3.32 — Deep conversion audit corrections
+
+- Correct Runtime iterator retry and exhaustion state, including strict and
+  non-strict zip, recovered mapping mutation errors, and files rewound after EOF.
+- Consume complete dictionary input pairs before checking their arity, preserving
+  prior updates and fixed-target assignment's separate consumption rule.
+- Add native/Python interaction witnesses and audit the complete test inventory.
+- Release pending Tools and quick-view callbacks when their window is destroyed;
+  keep standard window controls inside the menu bar at narrow widths.
+- Refresh active release assertions without changing sealed conversion contracts.
+- Update HTML Help examples and retain README.md byte-for-byte.
+- Verification details and platform limits: PyCForge-1.3.32-Verification.txt.
+
+# PyCForge 1.3.31 — Runtime text bookmarks and exclusive creation
+
+Runtime UTF-8 file workflows now support tell and bounded seek: restore a
+bookmark on the same open handle, rewind, retain the current position, or
+move to EOF. Unicode/newline lookahead is preserved; file iteration's telling
+restriction is observed. Bookmarks are opaque, handle-local values, not
+character indexes or portable offsets. Host C long limits still apply.
+
+Mode x creates a new file without overwriting an existing destination.
+FileExistsError is admitted as a recoverable builtin exception, with OSError
+and Exception parent matching. Writes after creation can still leave partial
+files on failure. Conversion itself performs no source-program file I/O.
+
+Seeking never resets resource counters. Bookmark storage is released on all
+close paths; live-file collection refusal and closed-handle collection remain
+intact. Internal PFile layout changed: regenerate C and rebuild callers.
+No dependency, UI control, save workflow, or README changes.
+
+HTML Help adds File bookmarks and exclusive creation, with runnable examples,
+search entries, precise limits, and updated file/exception references. See
+specifications/runtime_file_positions_1_3_31.md and the release verification
+report. Native Windows acceptance remains outstanding.
+
+Queued work includes separate C-module exports, binary/update file profiles,
+Typed record boundaries, and automatic collection with live temporary roots.
+
+---
+
+# PyCForge 1.3.30 — Explicit Runtime memory reclamation
+
+C callers can now use pv_collect between completed Runtime calls to reclaim
+unreachable values and cycles while retaining supplied PV roots and context
+state. Precise, non-moving tracing covers closures/defaults, shared containers,
+objects/methods, iterators/views, module bindings, and closed file handles.
+Released file-read buffers also return retained-file capacity.
+
+Collection is opt-in at idle C-call boundaries. It does not run inside Python
+loops or automatically at allocation failure, and it does not reset work/file
+budgets. Active calls/files, errors, invalid root metadata, and collector
+scratch allocation failure refuse collection before any sweep. Retained PVs
+must be supplied on each call; raw pointers alone are not roots.
+
+Internal allocation/closure layouts changed: regenerate C and rebuild callers
+together. Existing no-collection callers keep their original arena lifetime.
+No dependency, UI component, save workflow, or README changes.
+
+HTML Help adds Runtime memory and collection with a verified C caller and
+updates lifetime/file-budget guidance. See specifications/runtime_collection_1_3_30.md.
+Automatic collection within executing functions remains separate work requiring
+live temporary roots. Other queued upgrades include module .h/.c exports,
+expanded file profiles, and Typed record boundaries.
+
+---
+
+# PyCForge 1.3.29 — Runtime validation and ForgeLens
+
+Runtime conversion now records exact source-to-C emission ranges and checks
+final output through a separate validator before publication. Checks cover
+source identities and AST ranges, complete output byte coverage, Unicode
+coordinates, C lexical balance, callable declarations/definitions, and local
+jump destinations. ForgeLens uses the established authenticated workspace
+integration. Shared Runtime support remains C-only.
+
+PYC4698 reports internal validation failures without publishing new C. PYC4699
+continues to explain Runtime's contract: structural/provenance checks do not
+prove semantic equivalence or replace external compilation and testing. The
+Typed C-IR proof pipeline and Runtime arena lifetime remain unchanged.
+
+The requested scan/diagnostics audit found and fixed quick diagnostic navigation
+for untouched CRLF/CR files. Real edits, including edit followed by undo, still
+retire old diagnostic and scan locations. No replacement controls or new
+save workflow; the existing theme and components are retained.
+
+HTML Help adds Runtime validation and ForgeLens, with a verified example and
+updated contract/inspection guidance. README remains byte-for-byte unchanged.
+
+Next conversion work: value reclamation for long-running contexts, separate
+C-module exports, expanded file profiles, and Typed record boundaries.
+See specifications/runtime_validation_1_3_29.md and the verification report.
+
+---
+
+# PyCForge 1.3.28 — Runtime exception recovery
+
+Runtime conversion now supports selected `try`/`except`/`else`/`finally`
+control flow and builtin raises with optional literal messages. Matching
+handlers recover from ordinary runtime errors across calls and supplied
+modules. Cleanup preserves nested return, break, continue, and error order;
+file contexts close before control reaches an enclosing handler.
+
+Exception names are a closed documented set. Exception objects, `as` bindings,
+bare re-raise, chaining, exception groups, and custom exception classes remain
+unsupported with PYC4630 diagnostics. Allocation and execution-resource
+failures stay terminal: Python cleanup bodies are skipped after exhaustion,
+while automatic file cleanup still runs. Runtime context lifetime and the
+remaining ForgeLens/C-IR limitations are unchanged.
+
+HTML Help adds Exceptions and cleanup with executable examples, searchable
+reference entries, supported boundaries, and file/error guidance. README is
+byte-for-byte unchanged from 1.3.27. No dependency or save-control changes.
+
+This is the first stage of the accepted conversion upgrade program. Runtime
+validation/mappings, value reclamation, separate C-module exports, expanded
+file profiles, and Typed record boundaries remain subsequent work.
+See specifications/runtime_exceptions_1_3_28.md and the release verification
+report for scope and measured evidence.
+
+---
+
+# PyCForge 1.3.27 — Immediate stale Python scan results
+
+- Scanned-source edits immediately disable retained findings in both the full Python check dialog and recent-scan dropdown.
+- Stale panels are visibly muted and label their locations as scanned lines. Clean results also stop presenting themselves as current after an edit.
+- Invalidation persists through undo, hidden dialogs, renames and closed tabs until a new scan completes for unchanged source.
+- Changes to included companion modules invalidate the same scan; unscanned modules and tab switching alone do not.
+- Scan results completed after an intervening edit remain stale.
+- Navigation rejects old finding objects and queued callbacks from earlier scans, with a final freshness check before highlighting.
+- Preserves Windows newline normalization, existing scan analysis and conversion diagnostics behavior.
+
+# PyCForge 1.3.26 — Conversion diagnostics quick view
+
+- Added a separate amber warning-triangle button beside Tools.
+- Enabled only for current rejected/failed conversions that have Diagnostics records.
+- Opens a compact native dropdown with the same severity, code, module/line and message as the Diagnostics tab.
+- Clicking a located item selects its source module and highlights the reported range.
+- Source edits immediately close the list and disable access, including edits before delayed synchronization and edits in the split view.
+- Undo does not revive an invalidated result. Convert again to obtain fresh diagnostics.
+- Renaming/closing source, changing the source bundle, or starting another conversion disables old navigation.
+- Tab changes alone preserve valid results. Diagnostics without source locations remain readable but cannot navigate.
+- Long rows are elided with full tooltips; long lists scroll within the screen.
+- The Diagnostics tab, Python scan and conversion engine behavior are unchanged.
+
+# PyCForge 1.3.25 — Split Tools control and recent scan results
+
+- The wrench opens the regular Tools menu; the adjacent arrow opens recent Python scan results.
+- The divider has a clear gap before the two-part button.
+- The compact, scrollable dropdown reuses the scan dialog's findings, source navigation and dismissal state.
+- Distinct feedback covers no scan, an active scan, no errors/issues, removed findings and stale source.
+- Open full scan returns to the existing dialog; opening the dropdown never starts a scan.
+- Popup closure resets pressed and hover styling, including repeated menu action use.
+- Retains the v1.3.24 removal of the expandable scan scope row.
+
+# PyCForge 1.3.24 — Python check dialog cleanup
+
+- Removed the expandable Scan scope and limits row and its module/function count.
+- The results panels now have more vertical room.
+- Analysis notes remain available in the existing scan-status tooltip.
+- Scan logic and clickable issue-panel behavior are unchanged.
+
+# PyCForge 1.3.23 — Deeper Python code checks
+
+Check Python Code now follows supported top-level statements as well as functions.
+Explicit return, raise, break and continue paths survive loop and finally analysis.
+The checker models try/except/else/finally and conservative context-manager
+suppression, and tracks exception-target deletion. Findings explain the relevant
+assignment path or helper location.
+
+Bounded argument-sensitive helper analysis follows arguments, aliases, defaults and
+return values. Optional “Use open modules to trace imports” supplies unsaved companion
+source without importing or executing it. Findings remain on the selected tab;
+edits, renames or closure of any supplied tab make the retained scan stale.
+The scope/limits text is expandable so longer explanations do not crowd the panels.
+
+The four existing compiled Ting decision packs remain unchanged; the upgrade improves
+the evidence and paths they evaluate. Rule tests are retained, with new paired bug/clean
+regressions and authored runtime witnesses. Dynamic/unsupported analysis is explained.
+This checker addresses Python correctness only and adds no conversion-compatibility
+checks. Conversion support remains documented in the existing HTML reference.
+
+Limits: 16 modules, 1 MiB per module / 2 MiB total, 50,000 AST nodes per module,
+256 functions, 512 call contexts, 10 call levels, 100,000 flow operations,
+2,000 candidate facts, 200 displayed findings and 60 seconds.
+No dependencies are added; packaging remains one wheel. Native Windows interaction
+is to be verified with the supplied checklist.
+
+---
+
+# PyCForge 1.3.22 — Python code checker
+
+The Tools menu is now a wrench dropdown after the text menus and separator.
+Check Python Code appears above Run Python; F5 still opens Run Python.
+
+The modeless checker scans the selected tab’s current unsaved text in a cancellable
+worker. It combines Python syntax checks with four dedicated compiled Ting packs
+for assignment/reachability, supported None-value uses, local-call arguments and
+mutable defaults. Local function-return summaries support deeper findings without
+running or importing the program. Confirmed, conditional and review findings are
+kept distinct; unsupported analysis is reported in the dialog.
+
+A stage label, percentage bar and elapsed time accompany the scan. Results appear
+as stacked clickable cards: choosing one returns to the original tab and highlights
+its source. Cards and scroll position survive reopening. Right-click Remove dismisses
+a card; Re-scan replaces the results. Source changes mark retained results stale and
+block outdated navigation. Cancel or closing an active scan clears all panels and
+shows “Scan was halted.” There is no HTML export or automatic source editing.
+
+Limits: one tab, 1 MiB, 50,000 syntax nodes, 256 functions, 2,000 candidate facts,
+200 displayed findings and 60 seconds. Flow analysis covers supported function bodies;
+external imports, runtime-dependent behavior and complex control flow remain outside
+this first rule set. A clean scan is not a correctness guarantee.
+
+README and offline Help receive concise usage additions. Existing conversion behavior,
+the conversion bug tracker, dependency list and one-wheel packaging are retained.
+Native Windows/macOS interaction remains a separate platform verification step.
+
+---
+
+# PyCForge 1.3.21 — Internal audit corrections
+
+- F01: Track every active container during Runtime representation; preserve tuples inside sets/frozen sets and real list/dictionary cycles.
+- F02: Preserve negative zero when compensated summation has a zero correction, including the fallback materialization path.
+- F03: Reject Windows COM/LPT superscript-digit device aliases in every project path component.
+- F04: Permit project-checkpoint wording while retaining checks for obsolete converter-status labels.
+- F05: Maintain the current multiple-inheritance corpus expectation across release increments; keep historical overrides.
+- F06: Remove unread Typed locals only when all assignments are side-effect-free string literals and annotations agree; retain calls and potentially failing expressions.
+- F07: Use the current module-identity widget's public text API in the retained acceptance test.
+- R01: Project the latest snapshot before Python-open completion callbacks; wait for projected UI readiness in the split-view lifecycle regression.
+
+The README adds a dedicated conversion bug tracker immediately before contact information. HTML Help content and installation dependencies are unchanged. Native Windows and macOS verification remains a separate platform check.
+
+---
+
+# PyCForge 1.3.19 — Project bundles and filesystem reliability
+
+File → Project saves and opens portable .pcfproj bundles with a module preview,
+loading cover, named checkpoints, comparisons, and guarded restoration. Project
+saves preserve editor text independently of the linked Python files. Opening a
+bundle uses a new working folder; startup reconnects history without extracting
+older source over disk files.
+
+The filesystem audit adds protection against Save As aliases of another open
+module, clears old failed session paths after explicit project replacement,
+preserves existing bundle permission modes, and bounds startup history reads.
+Missing, damaged, slow, or invalid history locations appear in the Startup report
+without preventing use of the workspace. Save and restore failure paths retain
+the previous bundle and unsaved editor state.
+
+The searchable HTML Help includes a dedicated Projects and checkpoints page.
+The README retains its existing structure with a concise project-bundle section.
+The package version is 1.3.19. Existing historical files remain in the source
+archive; no conversion dependency or conversion behavior is changed.
+
+---
+
+# PyCForge 1.3.14 — Save All Python and shutdown verification
+
+File → Save All Python saves new and modified modules in order, asks for
+locations only when needed, and keeps the selected tab unchanged. The command
+is also available in the command palette. Save Python still applies to the
+selected tab; Save Python As remains available when no Python save is active.
+
+Save All and exit now share sequential asynchronous saves, avoiding overflow
+of the bounded file queue. Save commands cannot overlap. Cancellation and write
+failure release the busy state and leave unsaved modules open. Edits made while
+saving remain unsaved and prevent automatic closure. Exit also includes
+never-saved modules and waits for any individual save already in progress.
+
+Shutdown detaches both source views before their shared text buffers are
+released, preventing repaint against a deleted Qt document. Startup settings,
+conversion behavior, the external Python launcher, README, dependencies and
+version metadata are unchanged. Help explains saving and the distinction
+between the script console and the original Windows console.
+
+The final Linux/offscreen Qt suite passed 298 tests and 773 subtests, with no
+skips. Coverage includes 64-module saves and exit, immediate edits in both
+views, retries after failure/cancellation, repeated Save/Close, deferred buffer
+cleanup, fresh startup, session restoration and corrupt-settings recovery.
+Windows/macOS console construction is mocked; native desktop testing remains
+required. See PyCForge-1.3.14-Save-All.txt for installation and laptop checks.
+
+---
+
+# PyCForge 1.3.14 — Run Python and per-tab save state
+
+Tools → Run Python… (F5) opens a modeless, themed command dialog for the
+selected Python tab. Saved modules supply their absolute path and working
+folder automatically. Unsaved or modified modules show “Run Python — Module
+not saved” in the custom titlebar and disable the command box and Run button.
+The dialog follows saves and tab switches; it never saves or executes source
+merely because it was opened.
+
+The editable default uses the Python environment running PyCForge. Windows
+opens cmd.exe /k with console Python; Linux uses an installed terminal and
+retains the exit status/output; macOS opens Terminal. Run Python is separate
+from conversion and C compilation. Save Python now reflects the active tab's
+unsaved state in both the toolbar and File menu. Save Python As stays available.
+
+The application and distribution retain version 1.3.14. The converter, C build
+service, Ting runtime, README and Python dependencies are unchanged. Offline
+Help documents the commands. The focused/adjacent suite passed 226 tests and
+769 subtests on Linux with offscreen Qt. Real POSIX execution checks include
+relative file access, sibling imports, interactive input, arguments, unusual
+path characters and Python errors. Windows/macOS launch construction is
+covered through mocks; native desktop terminal checks remain for those hosts.
+See PyCForge-1.3.14-Run-Python.txt for installation and laptop checks.
+
+---
+
+# PyCForge 1.3.14 — UI review follow-up
+
+Keep the application and distribution version at 1.3.14 as requested.
+Completion suggestions now reject native window activation during mouse clicks,
+so scrollbar interaction retains editor focus. PgUp and PgDn navigate suggestions
+without moving the source caret. The compiler dialog uses an inset dropdown
+button and the existing down-chevron asset to preserve each field's outline.
+
+All 118 focused and adjacent regression tests and 652 subtests pass. The 24 UI
+cases also pass at 125% and 150% display scaling. A GCC build through the dialog
+succeeds and the executable returns the expected result. Validation uses Linux
+with Qt's offscreen backend; the Windows laptop interaction needs confirmation.
+
+Only two application source files change. README, screenshots, contact details,
+Help, conversion/build services, dependencies, and version metadata are retained.
+See PyCForge-1.3.14-UI-Review.txt for evidence and laptop checks. To replace an
+already-installed 1.3.14 from the updated local wheel, use --force-reinstall.
+
+---
+
+# PyCForge 1.3.14 — Help and README refresh
+
+Review and refine all 21 offline Help pages without changing conversion behavior.
+Seven restrained PyCForge caveats boxes explain integer bounds, context ownership,
+string construction, set ordering, annotation checks, cooperative inheritance,
+and file-write cleanup beside the relevant examples. A complete cooperative
+constructor diamond adds one runnable example; the existing examples are retained.
+
+Correct stale class limits, mode-specific module guidance, dependency wording,
+page links, and API-page navigation. Refresh the README's conversion and compiler
+coverage while retaining its introductory organization, starter examples, and
+exactly its two original screenshot links and image assets.
+
+The application version is 1.3.14. Converter contracts remain at their existing
+versions, including Runtime 1.3.13; converter/build sources and dependencies are
+unchanged. See PyCForge-1.3.14-Documentation-Review.txt for the page-by-page review
+and the executed documentation checks.
+
+---
+
+# PyCForge 1.3.13 — multiple inheritance conversion
+
+Runtime mode now converts multiple inheritance between declared classes with
+Python C3 method ordering, cooperative super calls, shared diamond fields,
+constructor selection, and subtype recognition through every base. Imported
+and re-exported bases retain their identity. Duplicate bases, inconsistent
+orders and field/method collisions reject conversion with source diagnostics.
+The complete ancestor closure remains bounded to 64 user classes plus object.
+
+Existing single inheritance and flat ordinary method dispatch are retained.
+No package dependency was added. Properties, static/class methods, dynamic
+bases and custom descriptors remain outside the documented class profile.
+See specifications/multiple_inheritance_1_3_13.md and the release verification
+report for the contract and measured checks.
+
+---
+
+# PyCForge 1.3.12 — conversion quality corrections
+
+- Preserve set iterator consumption, incremental difference updates, and numeric values selected by intersections.
+- Apply Typed scalar handling consistently in keyword arguments, comparison chains, fixed containers, branch-defined strings, and file operations.
+- Publish scalar scope facts in deterministic binding order across multiple functions.
+- Retain single inheritance, compiler profiles, completion improvements, and startup recovery from the preceding releases.
+
+See PyCForge-1.3.12-Conversion-Audit.txt for reproduced defects, verification evidence, and platform limits.
+
+# PyCForge 1.3.4 — Classes & Functions loading panel
+
+- Cover the complete tree area, including its header, with a themed panel while definitions are parsed and tree rows are populated.
+- Center a short 88 × 8 progress bar on the panel, with no visible loading text.
+- Reveal the tree and restore keyboard focus when loading finishes; stop the indicator on errors, source changes, or dismissal.
+- Preserve double-click and Enter navigation and the title-bar Copy action.
+- No new application dependencies or conversion changes.
+
+Validation: 37 focused tests and 50 subtests passed on Linux with offscreen Qt. Themed loading and loaded states were visually checked. Native Windows verification and a full-suite rerun were not performed for this patch.
+
+See PyCForge-1.3.4-Loading-Panel.txt for the exact scope and evidence.
+
+# PyCForge 1.3.3 — editor integration corrections
+
+- Completion preserves selected prefixes and rejects results after Escape, selection changes, or leaving the editor.
+- Delayed Go to Definition results retire when the caret, focus, or user intent changes.
+- Lambda parameter rename retains unrelated bindings and explicit keyword callers.
+- Document formatting accepts line movement around type-ignore directives while checking that each directive still covers the same statements.
+- Selection formatting handles repetitive source without false boundary errors and preserves unselected text.
+- Includes the split-view close, Find toggle, window-control hover, Generated C hover, and steady fold-arrow corrections.
+- Keeps all existing conversion coverage and unpinned application dependencies.
+
+# PyCForge 1.3.1 — reliability update
+
+This is one cumulative update to the complete PyCForge application.
+
+- Bind deferred Qt callbacks to their owner and release pending generated-C projection on shutdown.
+- Reject non-regular preview inputs without blocking on POSIX named pipes; retain UTF-8 and size checks.
+- Reap an outline child and close its handles if process startup raises after creating it.
+- Publish immutable source-token records incrementally to avoid holding two complete dictionary trees.
+- Enforce Typed token budgets during tokenization, preserving supported conversion output and diagnostic codes.
+- Preserve all Typed/Runtime, module/file, editor, Jedi/autopep8, tooltip, gutter and PCFC11 features.
+
+See PyCForge-1.3.1-Reliability-Audit.txt for exact findings, measurements, validation and remaining native-platform checks.
+
+# PyCForge 1.3.0 — complete consolidated release
+
+One installation now contains the complete 1.1.12 advanced conversion/editor
+line plus the 1.2.2 PCFC11 integration and additional resource-lifecycle fixes.
+There is no choice between conversion coverage and compilation support.
+
+- Both Typed and Runtime modes; runtime strings, lists, dictionaries, classes,
+  closures, comprehensions, everyday builtins/formatting, supplied modules and
+  connected UTF-8 file workflows are retained.
+- Current editor tools, shared work admission, bounded caches, Open/New Module
+  recovery and fold-marker fixes are retained.
+- PCFC11 dialog focus and custom compiler/output chooser fixes are included.
+  Object and executable builds accept both conversion ABIs. Runtime executable
+  adapters handle errors and destroy their value context before returning.
+  Windows UCRT compatibility headers supply runtime declarations missing
+  from PCFC11 0.1.1; Windows assembly generation is checked at O0 and O1.
+- Cancelled application startup now finishes and releases its modal dialog,
+  preventing it from blocking subsequent windows and keyboard shortcuts.
+- Conversion cancellation is retained throughout request encoding/spawning; idle
+  service frames release payloads. Modal children are destroyed; hidden timers
+  stop. Slow file previews cannot keep the interpreter alive through Qt's pool.
+  Regular workspace file reads are bounded to 16 MiB and reject special files.
+- The README and 21 offline Help pages describe the combined application.
+  Existing screenshot links and advanced runtime implementation are preserved.
+
+PCFC11 remains a separately installed compiler with a system assembler/linker.
+The package adds no dependency beyond those already required by 1.1.12.
+Native Linux validation is recorded in evidence/consolidation. Native Windows
+acceptance and actual laptop energy measurements remain outstanding. Runtime
+values retain their documented arena lifetime; whole-process memory is not
+bounded by the arena budget. No PyPI publication was performed.
+
+The evidence/consolidation directory records this release's checks. Historical
+release notes and evidence below describe their original versions only.
+
+---
+
+# PyCForge 1.1.12 — resource ownership and process reliability
+
+This patch updates 1.1.11. Closed temporary dialogs and their filesystem models
+are destroyed after use; About clocks run only while visible. Idle conversion
+supervisors wait for work, and idle service threads release completed payloads.
+Conversion pipe transfers cannot block cancellation or shutdown. Malformed
+worker envelopes trigger process reclamation, and reaped process handles close.
+
+The app, package metadata, About, startup, Help and reports use the same product
+version. Converter source, semantic contracts, dependencies, and HTML Help
+content are unchanged. Earlier editor lifecycle and About improvements remain.
+
+Measured evidence, reproduced baseline failures, scope and native Windows
+acceptance steps are in evidence/resource_audit. These checks do not certify
+battery life or the absence of every possible resource leak.
+
+# PyCForge 1.1.11 — module closing and function folding
+
+The About dialog omits the Ting Shadow / Advisory badge. Application version
+metadata, window titles, startup, About, Help and package metadata use 1.1.11.
+
+Closing the final module with Generated C visible now clears the editor,
+Source Bundle, and actions without an active-document lookup. Open and New
+recover an obsolete navigator selection. Function fold markers are restored
+from current background structure after switching tabs or rehighlighting.
+Pending edits and obsolete structure results cannot restore old fold ranges.
+Converter behavior, conversion identifiers, and dependencies are unchanged.
+
+# PyCForge 1.1.10 — connected UTF-8 file workflows
+
+Runtime functions can now read text, process it through local or imported
+helpers, and write or append results. Scoped open calls support character-sized
+reads, line iteration/readlines, write/writelines, flush, and early close.
+UTF-8 contents support embedded NUL; paths support Unicode and reject NUL.
+Newline=None and newline="" have distinct documented translation behavior.
+
+Cleanup covers normal exits, return, break, continue, failed later opens, and
+runtime errors. Handles passed to helpers share their cursor; returned text
+outlives its handle. Per-context limits bound open handles, operations, retained
+read buffers, and per-handle input consumption. Obsolete transient read buffers
+are reclaimed while public values retain the established arena lifetime.
+
+The 21-page HTML Help is a user manual with no development-cycle status. It
+adds complete read/process/write examples, a three-module report, input and
+expected output files, operation tables, newline rules, and error guidance.
+Stale module-limit and install examples were corrected. README retains its two
+original screenshot links and 200-line limit. Dependencies are unchanged.
+
+Typed file functions retain their external status-pointer ABI; connected file
+calls use Runtime mode. Exception recovery, independent runtime C-IR validation,
+and exact runtime ForgeLens mappings remain outside this delivery. PYC4699 is
+retained. Native Windows acceptance is pending; no PyPI publication occurred.
+See specifications/runtime_files_1_1_10.md, fixtures/runtime_files_1_1_10, and
+evidence/files_1_1_10 for the contract, runnable report, and validation evidence.
+
+---
+
+# PyCForge 1.1.9 — runtime programs across supplied files
+
+Runtime conversion now accepts explicit source bundles. Named imports, module
+aliases, re-exports, imported classes/functions/constants, and immutable
+scalar/tuple module constants work with the existing runtime operations.
+Namespaces remain separate. Imports and defaults initialize in source order,
+once per C context; remaining supplied files initialize as explicit roots.
+
+The workspace converts all open documents. CLI conversion/validation accepts
+repeated `--module ID=PATH` and `--module-id ID`. C runtime failures now preserve
+the logical source file and line. Runtime artifacts can be inspected with the
+CLI. No installation dependency changed.
+
+Relative/star/local/conditional/cyclic imports, implicit packages, file discovery,
+writable globals, and general module execution remain excluded. Runtime file
+I/O and exception recovery remain the next coverage work. Runtime C-IR proof
+validation, exact ForgeLens mappings, and reclamation during a context lifetime
+remain unfinished. The development warning is retained. Windows acceptance is
+pending; no PyPI publication is part of this release.
+
+See `specifications/runtime_modules_1_1_9.md`, the four-file invoice fixture,
+and `evidence/modules_1_1_9/` for contracts, examples, and recorded verification.
+
+---
+
+# PyCForge 1.1.8 — everyday runtime conversions
+
+Runtime conversion now implements sum, min/max (key/default), abs, round,
+any/all, stable sorted and list.sort (key/reverse), lazy enumerate and zip
+(including strict), iter/next, and builtin function values such as key=abs.
+Lists add extend, pop, insert, remove, reverse, clear, copy, and index; tuples
+also add index. Shared list identity is preserved through mutations.
+
+F-strings, format(), and str.format() share bounded precision, width,
+alignment, sign, grouping, decimal/base and floating presentation. !s/!r/!a,
+named/numbered fields, field access, and nested width/precision are supported.
+Print/str/repr/ascii now render nested lists, tuples, dictionaries and views,
+including cycle markers. Numeric rounding uses exact binary64 decimal digits.
+
+Select Transpile → Runtime; the CLI uses --runtime-values. No installation
+dependencies changed. The README retains exactly its two screenshot links.
+The existing 20-page HTML Help now documents these operations and examples.
+
+Runtime remains a bounded development backend: one source document, no imports,
+module assignments, file I/O, exception recovery, generators or runtime sets.
+Integers are checked int64; floating sums follow Python 3.12 compensated summation.
+Formatting excludes locale-sensitive n, character c, z and custom protocols;
+width is at most 1,000,000 and precision at most 1,000. Numeric formatting needs
+C numeric locale and round-to-nearest. Values remain owned until pv_destroy().
+Exact ForgeLens mappings and the typed C-IR validation path are still absent.
+Native Windows acceptance and PyPI publication have not been performed.
+
+See specifications/runtime_values_1_1_8.md for the conversion contract and
+tests/test_everyday_runtime_1_1_8.py for native comparisons against Python.
+
+---
+
+# PyCForge 1.1.7 — editor responsiveness and correctness
+
+This release batches occurrence selection and caret merging, removes fold parsing
+from gutter painting, and fixes the large-document replacement transition.
+Unchanged documents reuse byte-bounded position and outline caches. Outline
+parsing runs in a persistent, cancellable process and extracts symbols without
+building conversion IR. A shared work budget prioritizes explicit operations,
+limits admitted CPU work to one or two jobs, and defers passive observers while
+typing. Current immutable source snapshots are shared between editor consumers.
+
+Editor workers retain bounded exact-request replies; formatting diffs are built
+in the worker. New edits still invalidate publication and preview authority.
+Cancellation stops active outline parsing, and obsolete revision indexes check
+for cancellation during scanning. Closed documents leave the document caches.
+
+Correctness fixes preserve multiple carets across physical modifier presses,
+prevent extra quote insertion inside comments/strings, replace the existing
+identifier tail when accepting completion, keep selection formatting inside its
+original lines, and correct form-feed navigation offsets. Unsafe inheritance,
+class-private, Unicode-alias, and decorated-parameter renames are refused with an
+explanation. Atomic saves retain existing permission modes and follow symlink
+targets rather than replacing the link.
+
+The typed/runtime converter implementations and dependency requirements are
+unchanged. Both README screenshot URLs are preserved. Local Qt measurements,
+regression results, and a focused Windows acceptance checklist accompany this
+candidate. Native Windows acceptance is pending; local timings are not a
+cross-platform input-to-display guarantee. No PyPI publication was performed.
+
+---
+
+# PyCForge 1.1.6 — professional Python editing
+
+This release adds smart pairs and selection wrapping, up to 256 simultaneous
+cursors, regex and selection-scoped search, previewed replacement across open
+source documents, offline completion and parameter hints, definition navigation
+with return, current-document scope-aware rename with preview, and explicit
+undoable formatting of a document or selected lines.
+
+Edit now has compact Selection, Lines, Find and Replace, Code, and Folding
+Functions submenus. All native menu surfaces are bounded to the current monitor
+work area, using More Commands submenus for overflow. The existing toolbar is unchanged.
+
+Jedi 0.19.x and autopep8 2.3.x are new installation dependencies; parso and
+pycodestyle are installed with them. Editing runs offline. Source analysis and
+regex searches run in deadline-bound processes, use source as data, and reject
+stale results. No backups, autosave, recovery snapshots, or source execution were
+added. The Python-to-C converter implementations are unchanged from 1.1.5.
+
+Rename is limited to statically resolved references in the current document,
+refuses name collisions, and preserves imported exports with explicit aliases.
+Dynamic string lookups and references in other documents require manual review.
+Formatting checks syntax-tree equivalence before applying. Analysis accepts
+500,000 characters per document; search previews accept up to 64 open documents,
+4 million characters total, and 2,000 matches. Oversized results are not applied.
+
+Automated validation and native Windows acceptance status are recorded in the
+release evidence and Windows checklist included with the distribution bundle.
+
+# PyCForge 1.1.5 — conversion mode selection and C scrollbar
+
+The Transpile menu now contains exactly two mutually exclusive checked choices:
+Typed and Runtime. Choosing a mode does not convert. The existing Transpile
+button and Ctrl+Enter execute the selected mode; the choice is remembered
+between launches, initially defaulting to Typed. Mode changes retire the previous
+result so it cannot be saved as current until conversion succeeds again.
+
+Generated C now uses its normal scrollbar without the dense mapping overview
+strip. Search, mapping navigation, read-only output, and ForgeLens highlighting
+remain available. The hidden strip performs no marker overview projection.
+
+No backup, autosave, recovery, snapshot-history, compiler, or other suggested
+feature is added. The typed and runtime conversion capabilities are unchanged
+from 1.1.4. CLI and Python API mode selection are unchanged. Both README
+screenshot URLs are preserved. Native Windows acceptance remains pending.
+
+---
+
+# PyCForge 1.1.4 — ordered runtime dictionaries
+
+Runtime value conversion now handles ordered mutable dictionaries, dictionary
+comprehensions, dict[K, V] annotations, scalar/immutable-tuple keys, key deletion,
+and get/setdefault/update/copy/clear/pop/popitem. Live keys/values/items views
+support iteration, length, truth, membership, and list/tuple snapshots.
+
+Shared references, first-insertion order, equal numeric keys, definition-time
+defaults, and nested mutable values are preserved. A hash index supports ordinary
+lookup workloads. Memory, work, missing-key, key-type, and iterator mutation
+checks use the existing C context. Active dictionary iterators permit value
+replacement and reject structural key changes, including equal-size changes.
+
+The existing runtime action, CLI, and API expose these additions. Searchable
+HTML help, the supported-conversions table, README, and examples describe the
+implemented forms and boundaries. Both README screenshots retain their URLs.
+No new dependencies, source execution, embedded C compiler, or PyPI publication
+are introduced. See specifications/runtime_values_1_1_4.md and the new tests.
+
+This is a development candidate with a documented Python subset. Native
+Windows acceptance remains outstanding; performance needs workload benchmarks.
+
+---
+
+# PyCForge 1.1.3 — practical conversion coverage
+
+The runtime value converter now implements default arguments, named keyword
+calls, positional-only and keyword-only parameters for functions, methods,
+constructors, and lambdas. Defaults are evaluated at definition time and keep
+shared mutable values; lambda defaults can capture each comprehension value.
+
+Unicode lower/upper, strip/lstrip/rstrip, whitespace and explicit-separator split
+with maxsplit, numeric text parsing, optional integer bases, finite float
+formatting, simple f-strings, print sep/end, and empty scalar/container
+constructors are implemented. Unsupported calls on known receiver types have
+source diagnostics. Ryu supplies shortest binary64 decimal formatting under its
+Boost license; Unicode case data is pinned to Unicode 15.0.
+
+The README and installed HTML help describe these operations as supported
+features, include runnable examples, and retain the two screenshot-only README
+links. The existing typed converter, PySide6 workspace, Ting runtime, splash,
+and PlutoAI boundary remain in place. No PyPI publication is performed here.
+
+Validation is recorded in `evidence/coverage_1_1_3/validation_report.json`.
+The preceding 1.1.2 audit and its evidence are retained below as history.
+
+---
+
+# PyCForge 1.1.2
+
+1.1.2 includes a native correctness audit and eight demonstrated fixes. See `docs/CONVERSION_AUDIT_1_1_2.txt` for reproductions, verified coverage and remaining limits.
+
+## 1.1.2 conversion improvements
+
+Built on the supplied 1.1.1 source. Choose **Transpile → Transpile Runtime Values (Preview)** for real runtime Unicode strings, shared mutable lists and class instances, mixed lists and tuples, union/container annotations, nested filtered list comprehensions, and lambdas with captured cells. The default typed converter remains available.
+
+The preview emits self-contained C11 with an explicit arena and checked runtime operations. It converts one document and always identifies its development status. Exact ForgeLens mappings, the established C-IR proof guarantees, complete Python coverage, and native Windows validation are not yet provided by this new backend. Read [the preview contract](specifications/runtime_values_1_1_2.md) for supported forms, memory ownership, type-check boundaries, and remaining work.
+
+The embedded Ting execution runtime is now **0.10.0a21**. PyCForge installs **NumPy 2.3.x and Numba 0.63.x** with PySide6 and supports Python **3.11–3.13**. The existing splash warms real numeric kernels on a background worker while the interface stays responsive.
+
+Historical 1.1.2 scope: source conversion only. Superseded by the PCFC11 integration in the consolidated 1.3.0 release above.
+
+```bash
+python -m pycforge convert example.py --runtime-values --output generated.c
+```
+
+The material below describes the preceding default-profile history unless explicitly updated.
+
+---
+
+# PyCForge Current Contract Index
+
+Current candidate: `1.1.7` / editor responsiveness and correctness
+Release state: development preview; no PyPI upload or promotion authorized
+Current validation: see `evidence/correctness_1_1_2/validation_report.json`.
+Prior default-profile validation: `evidence/scalar_1_1/validation_report.json`.
+The following historical results and profiles remain preserved as predecessor evidence.
+Converter boundary: `scalar-strings-v1.1` / `c-renderer-v1.1`, using base C IR `0.16.0`
+Workspace boundary: `pycforge-workspace/0.8`
+Worker protocol: `pycforge.worker-protocol/0.2`
+Action registry: `pycforge.action-registry/0.6`
+Visual system: `pycforge.visual-system/0.5`
+Presentation settings: schema `3`
+Review predecessor: authenticated historical `0.16.3` source archive
+Roadmap authority: Revision 3.1 plus Revision 3.2 and Revision 3.3 addenda
+
+PyCForge is a deterministic Python-to-C source transpiler. Its terminal
+artifact is independently validated C11 source. It never imports or executes
+user Python, never opens a path selected by source Python during conversion,
+and exposes no compiler, assembler, linker, loader, runner, debugger, terminal,
+toolchain, plugin, project explorer, external-command surface, or generated-C
+editor. Generated C remains read-only and explicit-save-only.
+
+The 1.0.5 package retains the 1.0.1 fixed function-local numeric and Boolean
+set profile with once-evaluated bounded `in`/`not in` membership. It also adds
+authenticated membership facts and 1.0.1 rules, Python-only function folding,
+custom chrome on every dialog, linked-file session restoration with explicit
+failure reporting, and read-only six-agent Ting feedback with a current-state
+graphical Flow Map. Fourteen classified offline HTML Help pages document the
+complete admitted set profile and each new workspace behavior. Generated C
+remains immutable, and the Ting shadow review cannot alter conversion.
+
+The desktop begins with a genuine zero-document workspace. The first opened or
+created module becomes primary automatically, while the first, only, or final
+restored tab can always close. Linked files still open at normal exit restore
+in order with their active tab; closing the final tab persists an empty restart.
+Recent-file history is independently clearable without touching open tabs,
+disk files, or the restart session.
+
+During ordinary typing the toolbar, conversion-state labels, generated-C state,
+active source breadcrumb, and lower-left persistent status message remain
+visually stationary. Conversion progress appears only for actual conversion
+work. Python source and generated-C text sizes persist independently, defaulting
+to 14 pt and 12 pt, with a durable preference mirror protecting accepted sizes
+across restart and presentation-schema cleanup. Ordinary non-editor components
+copy the exact reviewed menu font, retaining its 11 pt minimum or a larger
+Windows accessibility choice. The Source Bundle, Python Source, and Generated C
+caption bands use a compact 9 pt hierarchy with adaptive identity elision;
+Help article content independently retains its 11–13 pt reading hierarchy.
+Screen-aware logical geometry keeps all top-level windows inside the current
+monitor work area. The Open preview no longer inherits the Python editor size.
+Transpilation Details always starts hidden; opening it creates a resizable
+lower inspector at 38 percent of the available workspace, preserving editor
+context. Help/About render the redesigned multi-resolution raster identity at
+the final display scale.
+
+Only Python source editors expose parser-authenticated function folds. Fold
+application synchronizes document geometry across shared source views, moves
+each cursor out of a newly hidden block, and preserves final-function access
+through Generated C visibility changes. Large-source Fold All uses the existing
+latest-wins background structure observer, validates the exact document
+revision, and never performs a full parse on the UI thread. Every dialog uses
+canonical branded frameless chrome without the retired gradient surface.
+Normal shutdown stores at most 64
+unique linked Python paths plus the active linked path; startup reopens them
+sequentially and reports every missing or unreadable target. Unsaved source is
+never stored. Long main-window identities are bounded and elided before the
+window controls, and Find/Replace keeps Previous and Next in a compact adjacent
+group. Converted and rejected decisions enable an internal read-only
+Ting feedback dialog with an overview and one tab per registered agent. Its
+read-only graphical Flow Map renders the current source-free evidence fan-out,
+live decision states, bounded proof counts, and immutable advisory fan-in; it
+is not a command shell or an execution surface.
+
+Six deterministic Ting agents now provide bounded, explainable shadow review
+of syntax, semantics, ownership, lowering, verification, and typed capability
+evidence. The pruning policy executes every registered agent and uses verified
+schema/index work only; it never speculatively skips a proof role. The public
+package contains a private execution-only Ting runtime plus six precompiled,
+digest-bound Compact-IR artifacts. That runtime includes the bounded `.ting`
+Compact-IR loader/parser and verifier needed to decode and materialize those
+artifacts. It excludes the authoring-side RuleSpec source parser, Compact-IR
+compiler, artifact writer, builder, console, history/reference subsystem, and
+standalone command entry point. The compiler and source parser are retained
+only in a separate private custody source package for authorized future rule
+releases.
+
+The desktop startup dialog authenticates and parses every shipped `.ting`
+artifact before the workspace is exposed. Its progress advances only after
+real work, uses no artificial timer or network access, permits cancellation at
+safe stage boundaries, and leaves validation errors visible instead of opening
+a partially initialized application.
+
+The 0.16.1 workspace added passive ForgeLens, the coordinated blackened-steel
+visual system, and bounded custom Open/Save browsers without changing
+conversion semantics or generated C.
+
+The active 0.16.0 converter is the additive successor to sealed Phase 14D. It
+adds independently validated selective scalar scope hoisting, exact loop-else
+completion ownership with overflow-safe signed-64 range updates, and one closed
+bounded UTF-8 file read/write profile. Explicit historical Phase 14 and 14D
+requests retain their exact predecessor schemas, diagnostics, bytes, hashes,
+rejections, and helper custody.
+
+`specifications/feature_matrix.json` remains the sealed executable Phase 14D
+`pycforge.feature-matrix/0.14.3` custody artifact. It is not relabeled as the
+active Phase 16 contract index; this document and the Phase 16 specifications
+below own the active successor boundary.
+
+The 1.1.0 scalar expansion adds checked local declarations and assignments,
+closed module scalar initialization, and allocation-free UTF-8 operations.
+See `specifications/scalar_strings_1_1.md` for exact boundaries and diagnostics.
+
+## Release lineage and custody
+
+Phase 16 `0.16.0` is implemented, validated, promoted, and sealed.
+PyCForge 1.0.5 retains those base schemas, renderer, and individually versioned
+1.0.1 set rules while refining public presentation and notification behavior.
+PyCForge 0.16.3 added installed Help
+and workspace usability; 0.16.2 repaired the virtual-EOF
+frontend boundary and hardening only desktop workspace and presentation
+behavior. Its presentation identities were `pycforge-workspace/0.6`,
+`pycforge.action-registry/0.3`, and `pycforge.visual-system/0.3`. PyCForge
+0.16.1 remains the preserved ForgeLens and blackened-steel
+predecessor. Phase 15C `0.15.2` remains preserved historical custody evidence
+with its canonical artifacts intact. The preserved
+0.15.3 workspace candidate changed only desktop behavior and presentation: it
+migrates the required binding to PySide6/Qt 6, adds persisted Python-editor
+sizing and Python auto-indent, and removes passive generated-C mapping overlays
+while preserving mapping navigation and immutable output. Its converter
+contract remained sealed at `0.14.3`.
+
+The base distribution now requires `PySide6>=6.8,<7`; no `workspace` extra is
+needed or provided. That workspace candidate did not claim the wider Phase 15D
+visible-platform gate: physical Windows/Linux rendering, display scaling, and
+assistive-technology certification remain unopened.
+
+The application never compiles or executes generated C. Version 1.1 release
+validation uses an external GCC test harness to compare generated functions
+with Python. File-system effects occur only when a caller separately builds
+and runs the generated C outside the application.
+
+## Active identities
+
+| Surface | Active identity | Authority |
+|---|---|---|
+| package | `1.1.1` | `pyproject.toml` |
+| converter contract | `0.16.0` | `pycforge/converter/contracts/versions.py` |
+| rule set | `scalar-strings-v1.1` | `pycforge/converter/contracts/configuration.py` |
+| set rules | `pycforge101.container.set_literal@1.0.1`; `pycforge101.container.set_membership@1.0.1` | `pycforge/converter/analysis/planning.py` |
+| renderer | `c-renderer-v1.1` | `pycforge/converter/contracts/configuration.py` |
+| runtime policy | `phase16-bounded-runtime-v0.16.0` | `pycforge/converter/contracts/configuration.py` |
+| workspace | `pycforge-workspace/0.8` | `pycforge/ide/__init__.py` |
+| worker IPC | `pycforge.worker-protocol/0.2` | `pycforge/ide/worker_protocol.py` |
+| action registry | `pycforge.action-registry/0.6` | `pycforge/ide/__init__.py` |
+| visual system | `pycforge.visual-system/0.5` | `pycforge/ide/__init__.py` |
+| settings | schema `3` | `pycforge/ide/qt_contract.py` |
+| Ting agents | six roles, shadow mode | `pycforge/ting_agents/rulesets/registry.json` |
+| Ting pruning | `pycforge.ting-pruning/schema-indexed-exhaustive-v1` | `pycforge/ting_agents/coordinator.py` |
+| Ting runtime | `0.1.0a21`, execution-only | `pycforge/_vendor/ting_reasoner_provenance.json` |
+| source bundle | `source-bundle/0.2` | `specifications/source_bundle.md` |
+| Python grammar IR | `python-ir/0.4` | `specifications/python_ir_schema.md` |
+| conversion plan | `conversion-plan/0.16.0` | `specifications/analysis_and_planning.md` |
+| C IR | `c-ir/0.16.0` | `specifications/c_ir_schema.md` |
+| generated artifact | `generated-c/0.16.0` | `specifications/result_and_fingerprints.md` |
+| decision trace | `pycforge.decision-trace/0.16.0` | `schemas/decision_trace.schema.json` |
+| conversion summary | `pycforge.conversion-summary/0.16.0` | `specifications/result_and_fingerprints.md` |
+| result serialization | `0.5` | `pycforge/converter/contracts/versions.py` |
+| scope-lifetime facts | `fact-table/0.16-scope-lifetimes` | `pycforge/converter/scope_lifetimes/model.py` |
+| loop-completion facts | `loop-completion-fact/0.16` | `pycforge/converter/loop_completion/model.py` |
+| file-I/O facts | `file-io-facts/0.16` | `pycforge/converter/file_io/model.py` |
+| file helper registry | `phase16-file-io-support-templates-v0.16` | `pycforge/converter/support_templates/registry.py` |
+| target/semantics | `c11-portable-fixed-v1` / `strict-source-v1` | active converter specifications |
+
+## Active Phase 16 capability boundary
+
+The 1.0.1 set profile admits one directly assigned function-local literal with
+1–64 unique, homogeneous direct `int`, finite `float`, or `bool` elements. A
+matching expression may use `in` or `not in` against that local name. Analysis
+publishes complete `container-membership-facts`; validation reconstructs the
+Python IR, binding, capacity, element category, operator, and supported or
+rejected closure. Lowering evaluates the searched expression once and compares
+it against read-only automatic C storage. Empty, duplicate, heterogeneous,
+computed, or string sets; inline membership sets; comprehensions; indexing;
+iteration; mutation; methods; aliases; rebinding; passing; return; and escape
+fail closed with PYC3402/PYC3403/PYC3406/PYC3410/PYC3411/PYC3412 as applicable.
+
+Selective scalar scope-lifetime proof admits an ordinary `int`, `float`,
+`bool`, or `str` local whose first stores lie in exhaustive conditional
+branches when every reachable continuation definitely initializes the binding
+before use. Nested conditionals and a surviving branch after its sibling
+returns are reachability-aware. Lowering declares the scalar once at function
+entry without a synthetic initializer and preserves branch assignment order.
+Loops, containers, records, closures, globals/nonlocals, missing coverage,
+read-before-definition, and incompatible categories do not silently widen the
+candidate. Complete `fact-table/0.16-scope-lifetimes` evidence and bounded,
+independently reconstructed proof are required.
+
+Admitted `while`, positional-`range`, and fixed list/tuple/dictionary loops may
+have `else`. Natural termination and zero iterations run the suite; only a
+`break` owned by that exact loop suppresses it. Nested breaks do not affect the
+outer loop, `continue` preserves completion, and `return` bypasses the suite.
+A Boolean completion flag exists if and only if the loop owns a break. Range
+updates use a structured pre-addition guard so crossing the signed-64 boundary
+selects the staged stop value without C signed overflow. Exact
+`loop-completion-fact/0.16` records authorize lowering.
+
+The file profile is exactly one direct synchronous one-item
+`with open(path, "r" or "w", encoding="utf-8", newline="") as fresh_handle`
+inside a top-level function, with one direct read-transfer or one direct write
+of an already-proved string name or string literal whose count is discarded.
+Calls and other effectful write expressions reject with `PYC3905` because the
+helper-internal open cannot preserve context-entry ordering. Reads default to
+1,048,576 bytes and are capped at
+16,777,216; they reject over-limit input, embedded NUL, non-RFC-3629 UTF-8,
+read errors, and close errors. Writes require an exact byte count and propagate
+close failure. Handles cannot alias, rebind, escape, survive the region, or be
+explicitly closed; source calls into file-effect functions reject.
+
+Every generated file-effect entry point has one hidden final, required non-null
+`int64_t *` status parameter pointing to external caller-owned storage. Codes
+are 0 success, 1 open, 2 allocation, 3 read, 4 limit, 5 embedded NUL in read
+content, 6 invalid UTF-8 in read content, 7 close, and 8 write. A successful read returns one unique
+`malloc`-owned `char *`; the external caller must `free` it. Conversion itself
+never opens the path or observes any runtime file contents or status. The
+generated entry null-guards the pointer and then initializes status 0 before
+source-controlled work; an independent C-IR/text conformance check authenticates
+that order and rejects missing, duplicated, or reordered initialization.
+
+The external C caller must also satisfy the published C-string preconditions:
+path is non-null, NUL-terminated valid UTF-8; borrowed write text has the same
+preconditions and no embedded NUL. Generated helpers do not runtime-validate
+pointer validity, path UTF-8/NUL properties, or bytes hidden after the first
+write-text terminator. Source literals containing NUL reject as `PYC3903`
+(path) or `PYC3905` (write). Status 5/6 validation applies to read file content.
+
+## Historical 0.15.3 workspace candidate and Phase 15C predecessor
+
+Phase 15C began from the promoted and sealed Phase 15B release:
+
+- source archive: `pycforge_phase_15b_v0_15_1.tar.gz`;
+- archive root: `pycforge_phase_15b_v0_15_1`;
+- size: 1,544,352 bytes;
+- SHA-256:
+  `aefaebbacb12b458bcadd9aa25ac9f2678a374b51901bcc51aab3698049cd827`;
+- release-tree fingerprint:
+  `d90225e2e75842dfd2ca581c08b844a3e640988e385cfc70a68dba8f27db9b36`;
+- converter-subtree SHA-256:
+  `a45bc2c31b954f9856c8eab36e95f68b086d5fdd682d2cf47ba2186887743124`.
+
+That authenticated archive and its `0.15.1` wheel remain the Phase 15C
+predecessor. The immediate 0.15.3 rollback is the published `0.15.2` release.
+
+## Preserved 0.15.3 workspace implementation
+
+### Documents, panes, and authoring
+
+Workspace session state stores bounded document identifiers only. The Python
+source workspace has document tabs and at most two synchronized panes. It does
+not duplicate semantic source authority or admit an unbounded editor grid.
+
+Python authoring includes undoable duplicate, move, indent, outdent,
+comment-toggle, and auto-indent operations. Enter preserves existing leading
+whitespace and adds one four-space level after a genuine suite-opening colon.
+Go-to-line uses document blocks instead of copying complete source. Whitespace
+display and folding are presentation state. Python source uses a persisted
+8–48 point size with a 14 pt default; generated C has an independent 8–48
+point size with a 12 pt default. Neither setting scales application chrome.
+Existing line numbers, current-line treatment, syntax, bracket, overview,
+undo/redo, select, and literal find/replace foundations remain intact.
+
+Generated C is immutable. Passive mapping backgrounds and underlines are
+suppressed for readability, while mapping records, overview-rail markers, and
+explicit navigation remain available. Its exact context allowlist is Copy,
+Select All, and Find. Save C requires a complete current result whose
+authenticated bundle fingerprint matches the committed workspace.
+
+### Structure, navigation, and search
+
+Outline and breadcrumb data derives only from immutable already-open normalized
+Python source. Analysis is cancellable and latest-wins, and it is bounded to:
+
+- 64 documents;
+- 4,096 outline symbols;
+- depth 64;
+- 256 characters per symbol name; and
+- 256 KiB source text per projection.
+
+Invalid syntax is inert and cannot retire valid structure for another open
+document.
+
+Find in Source Bundle searches immutable path-free snapshots of one to 64
+already-open documents. It performs no file I/O, project discovery, import
+resolution, or host scan. Results carry Python and UTF-16 positions, bounded
+previews, deterministic bundle/source order, and a global 5,000-match
+projection cap.
+
+### Action discovery and observers
+
+The command palette searches enabled, visible static registry actions. It owns
+no handlers, provides no free-form command path, caps queries at 256
+characters, and projects at most 50 results.
+
+Session transpilation history stores at most 64 immutable payload-free terminal
+records. It does not retain source, generated C, diagnostics, mappings, facts,
+summaries, traces, telemetry, or worker envelopes.
+
+Diagnostics, mappings, Conversion Summary, Decision Trace, Telemetry, outline,
+bundle-search results, and history use bounded observer panels. Generated C
+remains a read-only incremental inspection surface.
+
+### Action and visual inventories
+
+The import-safe action registry contains:
+
+- 57 action specifications;
+- 56 static actions;
+- one bounded recent-file dynamic template;
+- 19 declared surfaces;
+- six persistent main menus; and
+- eleven context surfaces.
+
+The main menus are File, Edit, View, Navigate, Transpile, and Help. Persistent
+`QAction` construction remains singly owned by `pycforge/ide/qt_actions.py`.
+
+The visual catalogue contains 55 safe self-contained icons at nine PNG
+resolutions each, including the canonical PyCForge brand mark and Help icon.
+The retired About glyph is absent; the main shell and About dialog use the same
+brand mark. The shared stylesheet covers document tabs, split panes,
+breadcrumbs, outline, bundle search, history, the command palette, Help, and
+contained status chrome.
+
+## Historical Phase 15C real offscreen Qt evidence
+
+Phase 15C records current-release runtime evidence, not inherited historical
+evidence:
+
+- Python `3.12.13`;
+- PyQt `5.15.11`;
+- Qt build `5.15.14` and runtime `5.15.19`;
+- QPA platform `offscreen`;
+- exactly one real `QApplication`;
+- 18 focused workspace cases with zero failures, errors, or skips;
+- a 250,113-character source fixture;
+- window construction in 0.054 seconds, below the 8-second bound;
+- first event-loop turn in 0.0103 seconds, below the 1-second bound;
+- a 0.01-second timer producing 110 ticks during 1.201 seconds of isolated
+  transpilation, below the 30-second bound;
+- large-file mode active with the syntax highlighter detached;
+- shared editor-buffer authority preserved; and
+- zero new PyCForge threads after close and zero worker leaks.
+
+A small end-to-end workspace conversion completed in 0.408 seconds as
+supporting evidence. The 18-case widget record is the canonical Phase 15C
+runtime evidence.
+
+These 0.15.2 checks use real PyQt widgets on the offscreen QPA backend. They do not
+constitute visible desktop, physical-screen, display-scaling, or
+assistive-technology evidence.
+
+## Preserved responsiveness and safety
+
+Phase 15A process isolation and Phase 15B command/visual custody remain binding:
+
+- conversion runs in a spawned child process;
+- exactly one active and one replaceable latest pending request is admitted;
+- cooperative cancellation has bounded hard-termination fallback;
+- exact generation, revision, bundle, request, and transport guards control
+  publication;
+- stale, failed, canceled, partial, malformed, oversized, or superseded work
+  cannot publish or save C;
+- file I/O, hashing, revision/index construction, literal search,
+  source-structure analysis, and guarded atomic writes remain outside the GUI
+  thread; and
+- large-file projections and generated-C population remain bounded or
+  incremental.
+
+Routine tab, pane, palette, history, go-to-line, and observer updates do not
+invoke the transpiler, scan the host, hash the complete bundle, or recursively
+build unbounded view state.
+
+The one-to-64-document `SourceBundle` remains the entire source universe.
+Python is the only editable code surface.
+
+## Checkpoint E debt disposition
+
+`CE-IDE-WORKSPACE-COMPLETENESS` is retired for the authorized Phase 15C scope.
+Every bounded authoring, navigation, action-discovery, observer, and immutable
+generated-C inspection family in the Checkpoint E boundary has an explicit
+implementation, fail-closed contract, and supporting real offscreen runtime
+evidence.
+
+The separate visible-platform and Phase 15D distribution debt remains open.
+Retiring the Phase 15C completeness item does not claim the complete Phase 15
+workspace.
+
+## Roadmap boundary
+
+Phase 15C adds no project explorer, recursive host scan, language server,
+formatter, semantic completion, refactoring engine, quick-fix mutation,
+source-control hosting, remote-file system, collaboration, cloud
+synchronization, arbitrary project configuration, plugin system, macro,
+external command, build/run/debug action, terminal, toolchain integration, or
+generated-C editing.
+
+Phase 15D, the wider distribution and real visible Windows/Linux PySide6 gate,
+remains unopened.
+
+## Supporting gates
+
+```text
+python -m unittest tests.test_phase12_2_qt
+python -m unittest tests.test_phase15c_action_contract
+python -m unittest tests.test_phase15c_command_palette
+python -m unittest tests.test_phase15c_source_editing
+python -m unittest tests.test_phase15c_source_structure
+python -m unittest tests.test_phase15c_workspace_search
+python -m unittest tests.test_phase15c_workspace_session
+python -m unittest tests.test_phase15c_session_history
+python -m unittest tests.test_phase15c_visual_system
+python -m unittest tests.test_phase15c_qt_command_contract
+python -m unittest tests.test_phase15c_qt_panels_contract
+python -m unittest tests.test_phase15c_qt_position_reverse
+python -m unittest tests.test_phase15c_qt_workspace_integration
+python -m unittest tests.test_editor_behavior_qt
+python -m unittest tests.test_editor_settings_qt
+python -m unittest tests.test_validate_phase16
+python -m unittest tests.test_phase15c_release_contract
+python -m unittest tests.test_validate_phase15c
+python -m unittest tests.test_phase15c_release_packaging
+python tools/validate_phase16.py --mode promotion
+```
+
+The active Phase 16 gate includes the preserved 0.15.3 PySide6 workspace gate
+and explicit historical Phase 14D converter custody rather than substituting
+for either. It does not invoke pytest or select tests; CI and release run the
+complete unfiltered pytest suite in a separate required step and report every
+conditional skip reason with `-rs`. The validator never executes source Python,
+opens a witness source-selected path, invokes a C toolchain, or executes
+generated C.
+
+Detailed Phase 15C scope and evidence are recorded under
+`transition/phase_15c` and `evidence/phase_15c`.