M7 Phase 1: thread %field_vals as a per-call lexical

Turn do_form's `local %field_vals` into an explicit per-call lexical
`my $field_vals = {}` and pass it into the nested load_persistent() as a
parameter, replacing the dynamic-scope dependency. Six sites, all inside
do_form.

Design note carried forward to Phases 2-3: %field_vals is per-call
recursion state, so it becomes a per-call lexical, NOT a key on the single
startup $ctx -- a shared $ctx->{field_vals} reset per call would clobber a
parent screen when forms nest, whereas the lexical preserves the old
`local` save/restore exactly. The startup $ctx stays for genuinely shared
state (cfg/process); per-screen state lives in per-call containers.
load_persistent taking the map explicitly sidesteps the named-sub closure
trap (a named inner sub binds the first call's lexical, not each call's).

Inventory correction: only load_persistent read %field_vals, not
sync_fields_val/save_persistent as the plan assumed.

Coverage gap closed: the gate the plan named did not exist -- the pty
tests only navigate default/empty fields. Added t/19-form-init.t, which
drives a form whose `init { command:... }` pre-fills a field and asserts
the value renders, exercising the field_vals write/read sites this phase
changed. Full suite now 309 tests; all four CI checks pass locally.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: claude

M7-CTX-PLAN.md

@@ -78,13 +78,25 @@ threading mistake shows up as a crash or a mis-drawn screen, not a silent pass.
   need `our`-declaring in place; moving ~120 of them up front is churn/risk for
   no near-term gain. Handle at Phase 6 (or skip — it is optional polish).
 
-### Phase 1 — `%field_vals` → `$ctx->{field_vals}`  *(8 sites — the pattern-setter)*
-- Smallest structure, but it is read by the **nested** `sync_fields_val` /
-  `save_persistent` / `load_persistent`, so this phase *is* where the §2
-  nested-sub conversion gets proven on a small surface.
-- Convert those three inner subs to take `$ctx` (option b). Replace `local
-  %field_vals` with `$ctx->{field_vals} = {}` per `do_form` call.
-- **Gate:** `t/08` (field defaults/values) + persistent-save tests must pass.
+### Phase 1 — `%field_vals` → per-call lexical  *(done — the pattern-setter)*
+- Reality check vs. the plan: only **one** nested sub actually reads
+  `%field_vals` — `load_persistent` (not `sync_fields_val`/`save_persistent`,
+  which the inventory had wrongly assumed). 6 sites total, all inside `do_form`.
+- **Design refinement (applies to Phases 2–3 too):** `%field_vals` is `local`,
+  i.e. *per-call* recursion state, so it became a per-call **lexical**
+  `my $field_vals = {}` — **not** a key on the single startup `$ctx`. A shared
+  `$ctx->{field_vals} = {}` per call would clobber a parent screen on nesting;
+  the lexical preserves the old `local` save/restore exactly. The startup `$ctx`
+  stays for the genuinely shared state (cfg/process). So per-screen state
+  (field_vals, menu, form, fp, cform) lives in per-call containers; `$ctx` holds
+  the shared parts. Nested `load_persistent` takes the map as an explicit
+  parameter (option b), sidestepping the named-sub closure trap.
+- **Coverage gap closed:** the gate the plan named ("field-values + persistent
+  tests") did not exist — the pty tests only navigate default/empty fields.
+  Added `t/19-form-init.t`, which drives a form whose `init { command:… }`
+  pre-fills a field and asserts the value renders, exercising the field_vals
+  write (init parse) and read (field creation) sites this phase changed.
+- **Gate:** full suite (309 tests) + the new `t/19` green.
 
 ### Phase 2 — `%menu` → `$ctx->{menu}`  *(38 sites)*
 - `load_menu` fills `$ctx->{menu}` (it already returns a structure from

ROADMAP.md

@@ -205,9 +205,12 @@ the conformance tests.
 - 🔄 **`$ctx` threading** (in progress): replacing `ccfe.pl`'s package globals
   and `local` dynamic scope with one explicit run-state object. Planned in
   **M7-CTX-PLAN.md** (phases 0–6, all in scope). **Phase 0 done:**
-  `CCFE::Context::new()` container built at startup (unused until Phase 1),
-  `t/18-context.t`, and the latent `perl (>= 5.36.0)` floor added to
-  `debian/control`. Next: Phase 1 (`%field_vals`, the nested-sub pattern-setter).
+  `CCFE::Context::new()` container built at startup, `t/18-context.t`, and the
+  latent `perl (>= 5.36.0)` floor added to `debian/control`. **Phase 1 done:**
+  `%field_vals` turned from a `local` global into a per-call lexical threaded
+  explicitly into `load_persistent` (proving the named-sub conversion on the
+  smallest surface); `t/19-form-init.t` added to cover the previously-untested
+  init→field-value path. 309 tests green. Next: Phase 2 (`%menu`).
 
 ## M8 — Non-functional close-out audit  _(final gate)_
 Five dimensions: **test coverage, code quality, performance, security,

src/ccfe.pl

@@ -2651,7 +2651,11 @@ sub do_form {
         $hidden, $hscroll, $script, $val, $form_dir
     );
     my ($fpad);
-    local %field_vals;
+    # M7 de-globalisation (Phase 1): the per-form field-value map is a per-call
+    # lexical, not a shared global -- this preserves the old `local %field_vals`
+    # recursion semantics (a nested screen gets its own) and is threaded into
+    # the nested load_persistent() explicitly rather than via dynamic scope.
+    my $field_vals = {};
     local %form;
     my ( @fields_to_remove, @fields_to_enable, @fields_to_disable );
 
@@ -2855,6 +2859,7 @@ sub do_form {
     }
 
     sub load_persistent {
+        my ($field_vals) = @_;
         my @res = ();
         my ( $fname, $hash );
 
@@ -2876,7 +2881,7 @@ sub do_form {
                     next if /^\s*#/;
                     chop;
                     my ( $id, $val ) = split /\s*=\s*/;
-                    $field_vals{$id} = $val;
+                    $field_vals->{$id} = $val;
                     trace( "  $id=\"$val\"", $LOG_FIELDS_VAL );
                 }
             }
@@ -2916,7 +2921,7 @@ sub do_form {
             if ( $action eq 'command' ) {
                 curs_set($OFF) if $HIDE_CURSOR;
                 my ( $wpan, $wwin ) = open_wait_msg;
-                undef %field_vals;
+                %{$field_vals} = ();
                 my $prev_path = $ENV{PATH};
 
                 my @res = ();
@@ -2963,7 +2968,7 @@ sub do_form {
                           ;    #$LOG_FIELDS_VAL
                     }
                     else {
-                        $field_vals{$id} = $val;
+                        $field_vals->{$id} = $val;
                         trace( "  $s=\"$val\"", $LOG_FIELDS_VAL );
                     }
                 }
@@ -2979,7 +2984,7 @@ sub do_form {
                 trace("unknown form init type \"$action\"");
             }
         }
-        load_persistent;
+        load_persistent($field_vals);
 
         $y           = 0;
         $npages      = 0;
@@ -3012,7 +3017,8 @@ sub do_form {
                 $all_ids .= " " if !( $form{fields}[$i]{option} );
                 $all_ids .= "%{$id}" if $id !~ /^$FSEP_ID_PRFX/;
                 if ( $type == $SEPARATOR and !defined($label) ) {
-                    $label = $field_vals{$id} ? $field_vals{$id} : 'ERROR!';
+                    $label =
+                      $field_vals->{$id} ? $field_vals->{$id} : 'ERROR!';
                 }
                 if ( $LAYOUT == $SIMPLE ) {
                     $len = $COLS - ( 52 + $rflags_size + 2 )
@@ -3026,7 +3032,7 @@ sub do_form {
                 my $lw = disp_width($label);    # label width in columns
                 $val = '';
                 $val = $default if defined($default);
-                $val = $field_vals{$id} if defined( $field_vals{$id} );
+                $val = $field_vals->{$id} if defined( $field_vals->{$id} );
                 $val = substr( $val, 0, $len )
                   if ( $hscroll == $NO )
                   and ( length($val) > $len );

src/t/19-form-init.t

@@ -0,0 +1,58 @@
+#!/usr/bin/perl
+#
+# Form init command -> field value population (regression for M7 Phase 1).
+#
+# A form's `init { command:... }` block runs a command whose `id=value` stdout
+# lines pre-fill the form's fields.  Those values flow through do_form's
+# per-form field-value map -- the `%field_vals` that M7 Phase 1 turned from a
+# `local` global into an explicit per-call lexical threaded into
+# load_persistent().  The existing pty tests only navigate a form of default
+# (empty) fields, so this drives the populated path end to end: it asserts the
+# init command's value actually renders in the field, which exercises the
+# field_vals write (init parse) and read (field creation) sites Phase 1 changed.
+#
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib "$Bin/lib";
+use File::Temp qw(tempdir);
+use Test::More;
+
+my $src = "$Bin/..";
+
+eval { require CCFE::Test::Pty; 1 } or plan skip_all => "pty helper: $@";
+plan skip_all => 'no Linux pseudo-terminal' unless CCFE::Test::Pty->available;
+plan skip_all => 'Curses not installed'     unless eval { require Curses; 1 };
+plan skip_all => 'no installer' unless -f "$src/install.sh";
+
+my $prefix = tempdir( CLEANUP => 1 );
+my $log    = `cd "$src" && sh install.sh -b -p "$prefix" 2>&1`;
+plan skip_all => "install failed: $log" unless $? == 0 && -x "$prefix/bin/ccfe";
+
+# A one-field form whose init command pre-fills that field with a known marker.
+my $objs = "$prefix/share/ccfe/objects/ccfe";
+open( my $fh, '>', "$objs/initval.form" ) or plan skip_all => "write: $!";
+print {$fh} <<'FORM';
+title { Init value test }
+field {
+  id    = GREETING
+  len   = 20
+  type  = STRING
+  label = Greeting
+}
+init { command:printf 'GREETING=hello-init\n' }
+action { run:true }
+FORM
+close($fh);
+
+plan tests => 2;
+
+my $pty = CCFE::Test::Pty->spawn( 80, 24, "$prefix/bin/ccfe", 'initval' );
+$pty->pump(1.3);
+my $screen = $pty->screen;
+
+like( $screen, qr/Greeting/, 'the form opens and shows the field label' );
+like( $screen, qr/hello-init/,
+    'the init command value is populated into the field (field_vals path)' );
+
+$pty->send("\e");    # leave the form; DESTROY reaps the child