Decode packed event records for runtime import

docs/README.md

@@ -67,16 +67,17 @@ Current local tool status:
 The atlas milestone is broad enough that the next implementation focus has already shifted downward
 into runtime rehosting. The current runtime baseline now includes deterministic stepping, periodic
 trigger dispatch, normalized runtime effects, staged event-record mutation, fixture execution,
-state-diff tooling, and initial persistence surfaces.
+state-diff tooling, and a packed-event persistence bridge that now reaches per-record summaries and
+selective executable import.
 
 The highest-value next passes are now:
 
 - preserve the atlas and function map as the source of subsystem boundaries while continuing to
   avoid shell-first implementation bets
-- deepen the `.smp` event bridge from collection-level structural summaries toward per-record
-  packed-body coverage
-- deepen captured-runtime and round-trip fixture coverage on top of the existing runtime CLI and
-  fixture surfaces
+- deepen captured-runtime and round-trip fixture coverage on top of the packed-event bridge that now
+  exists
+- widen packed-event target-family coverage only where static evidence is strong enough to support
+  deterministic executable import
 - use `rrt-hook` primarily as optional capture or integration tooling, not as the first execution
   environment
 - keep `docs/runtime-rehost-plan.md` current as the runtime baseline and next implementation slice

docs/runtime-rehost-plan.md

@@ -22,11 +22,12 @@ Implemented today:
 - snapshots, state dumps, save-slice projection, and normalized state diffing already exist in the
   CLI and fixture layers
 - checked-in runtime fixtures already cover deterministic stepping, periodic service, direct trigger
-  service, snapshot-backed inputs, and normalized state-fragment assertions
+  service, snapshot-backed inputs, normalized state-fragment assertions, and imported packed-event
+  execution
 
 That means the next implementation work is breadth, not bootstrap. The recommended next slice is
-the `.smp` event-collection structural bridge across inspection, save-slice loading, import, and
-snapshot-backed fixtures.
+captured-runtime depth plus wider packed-event target-family coverage, not another persistence
+scaffold pass.
 
 ## Why This Boundary
 
@@ -215,10 +216,12 @@ Current status:
 
 - runtime snapshots and state dumps are implemented
 - `.smp` save inspection and partial save-slice projection already feed normalized runtime state
-- the packed event-collection summary now survives into loaded save slices and projected runtime
-  snapshots, but per-record packed bodies are still deferred
-- the remaining gap is broader captured-runtime and round-trip fixture depth plus deeper `.smp`
-  event-body decoding, not the first persistence surface
+- the packed event-collection bridge now carries per-record summaries into loaded save slices,
+  projected runtime snapshots, normalized diffs, and fixtures
+- the first decoded packed-event subset can now import into executable runtime records when the
+  decoded actions fit the current normalized runtime-effect model
+- the remaining gap is broader captured-runtime and round-trip fixture depth plus wider packed
+  target-family coverage, not first-pass packed-event decode
 
 ### Milestone 4: Domain Expansion
 
@@ -347,8 +350,8 @@ The currently implemented normalized runtime surface is:
   `runtime summarize-state`, `runtime import-state`, and `runtime diff-state`
 - deterministic stepping, periodic trigger dispatch, one-shot event handling, dirty reruns, and a
   normalized runtime-effect vocabulary with staged event-record mutation
-- save-side inspection and partial state projection for `.smp` inputs, including the structural
-  packed event-collection summary
+- save-side inspection and partial state projection for `.smp` inputs, including per-record packed
+  event summaries and selective executable import
 
 Checked-in fixture families already include:
 
@@ -360,33 +363,35 @@ Checked-in fixture families already include:
 
 ## Next Slice
 
-The recommended next implementation slice is deeper `.smp` event persistence, starting from the
-structural bridge that already exists today.
+The recommended next implementation slice is broader captured-runtime depth on top of the packed
+event bridge that now exists today.
 
 Target behavior:
 
-- keep carrying the packed event collection across `inspect-smp`, `load-save-slice`,
-  `import-save-state`, snapshots, diffs, and fixtures
-- deepen that bridge from collection structure into per-record packed-body summaries
-- preserve the separation between parity-shaped packed state and executable normalized runtime state
-  until the packed layout is better decoded
+- keep the packed event bridge grounded against real captured save inputs rather than only synthetic
+  parser tests and snapshot fixtures
+- expand the executable import subset beyond the current direct-state and follow-on lanes only when
+  target resolution and field semantics are statically grounded enough to preserve headless
+  determinism
+- keep preserving unsupported packed rows as parity summaries instead of guessing executable meaning
 
 Public-model additions for that slice:
 
-- packed per-record event summary types on the `.smp` side
-- optional runtime-side parity summaries for imported packed event records
-- no new executable `RuntimeEffect` variants by default in that slice
+- additional captured-save fixture material for packed event collections
+- wider target-family summaries only where imported execution can be justified by current static
+  evidence
+- no shell queue/modal behavior in the runtime core
 
 Fixture work for that slice:
 
-- one or more snapshot-backed fixtures that prove imported packed event state survives normalize and
-  diff paths
-- synthetic report/save-slice tests that lock the first per-record packed-body parse shape
-- state-fragment assertions that lock imported collection ids, version, and record counts
+- captured `.smp` or save-slice-backed fixtures that prove real packed event records survive import
+  and diff paths
+- regression fixtures that lock the current selective executable import boundary
+- state-fragment assertions that lock both packed parity summaries and imported executable records
 
 Do not mix this slice with:
 
 - territory-access or selected-profile parity
 - placed-structure batch placement parity
 - shell queue/modal behavior
-- direct translation of packed RT3 event rows into executable normalized effects
+- broad speculative translation of packed RT3 event rows into executable normalized effects