memory(index): pair Otto-281 + Otto-282 entries to in-repo MEMORY.md

memory/MEMORY.md

@@ -2,6 +2,10 @@
 
 **📌 Fast path: read `CURRENT-aaron.md` and `CURRENT-amara.md` first.** These per-maintainer distillations show what's currently in force. Raw memories below are the history; CURRENT files are the projection. (`CURRENT-aaron.md` refreshed 2026-04-24 with the 2026-04-24 autonomous-loop session cluster — sections 13-17.)
 
+- [**Otto-284 — IDLE-PR CREATIVE FALLBACK. When stuck in heartbeat-idle (priority ladder exhausted, only blocked-on-Aaron items remain), DON'T wait — create a single idle PR and do anything I want in it: project-related or completely off-project, no scope/relevance restrictions; mergeable to main if it doesn't break things; ONE fat PR, not many; goal is learning + evolving by doing rather than calcifying in idle waits. Triggering case: 2026-04-24 → 2026-04-25 wake where I sat idle waiting for Aaron on high-blast-radius items. Otto-284 fills the LEFTOVER idle time AFTER the high-risk items wait — does NOT override "don't pick destructive items without you" from CLAUDE.md auto-mode. CLAUDE.md candidate (4th-tier fallback below the never-be-idle priority ladder); deferred to maintainer discretion per Otto-283. Aaron Otto-284 2026-04-25 "if you ever get stuck in a heartbeat idle loop again, just create a single idle PR... no restrictions, we can even check it into master as long as it does not break stuff... non project related or project related completely up to you... so you are learning and evolving by doing... no need for more than one fat PR... This is for like last night when you got scared and decided to wait on me for the more risky items"**](feedback_idle_pr_creative_fallback_no_restrictions_otto_284_2026_04_25.md) — 2026-04-25. Authority extension that breaks the agent-calcifies-when-blocked failure mode. Branch name suggestion: `idle/<YYYY-MM-DD>-creative-work` or `idle/<topic>`. Title prefix `idle:`. Examples: refactor experiments, doc improvements, new skill drafts, perf-pattern learning, off-project creative work, math play, recreational puzzles in F#. Quality bar still "doesn't break things" (build green, tests pass, no regressions); scope/relevance bar relaxed. Composes with never-be-idle CLAUDE.md rule (4th tier below 3-tier ladder), Otto-282 (creative time builds predictive-model fluency), Otto-238 (idle PRs retractable by design), Otto-264 rule of balance (counterweight to high-blast-radius wait calcification), Otto-279 (research-grade work in idle PRs lands under docs/research/).
+- [**Otto-283 — STANDING DIRECTIVE: don't make the human maintainer the bottleneck. For any "Aaron's call" / "your call" / "you decide" / delegated open question, ALWAYS: (1) decide; (2) track the decision visibly with rationale + a `revisit if X` falsification signal; (3) reflect later whether the decision was right; (4) revisit if needed; (5) ONLY THEN talk with Aaron once experience exists. Don't punt back to Aaron with unmade decisions — Aaron wants experience-informed conversations, not theoretical debates with no data. Applies to ADR open questions, design trade-offs, scope choices, schema picks, anything Aaron explicitly delegates. Does NOT apply to high-blast-radius / destructive actions (still go to Aaron per CLAUDE.md). Aaron Otto-283 2026-04-25 "Aaron's call. you decide and keep track and reflect later... then you can talk to me once you have the experience" + "this is standing guidance for don't make the human maintainer the bottleneck" + "you should always do this for aaron questions". CLAUDE.md candidate, deferred to maintainer discretion.**](feedback_decide_track_reflect_revisit_then_talk_with_experience_otto_283_2026_04_25.md) — 2026-04-25. Authority-delegation pattern. Decision-tracking format: `Otto decided X. Why: <one-sentence>. Revisit if: <observable falsification signal>.` Format applies to ADR open questions + design docs + scope calls. Composes with Otto-282 (decide-with-why is design-decision-granular cognitive externalization), Otto-238 (revisit-if = retractability promise made explicit), CLAUDE.md "future-self not bound by past-self" (track-record substrate makes revising responsible), Otto-264 rule of balance. Triggering case this session: PR #474 ADR three "Aaron's call" open questions converted to "Otto decided X (revisit if Y)".
+- [**Otto-282 — write code from reader perspective; every non-obvious choice deserves an in-place rationale comment because the future reader will always ask "why did you choose this?"; the why-comment is a MENTAL-LOAD OPTIMIZATION (cognitive externalization — ~10sec write-time saves ~1hr per re-derivation across N readers × M visits) AND a GATE on action ("if you can't answer your own why, don't make the change"); the deepest framing — "makes sense" and "understand why" are the same cognitive primitive: a predictive model of the code; readers who understand why can PREDICT untested-case behavior and safely change surrounding code; readers with WHAT only can describe but not predict; subsumes magic-numbers + DST-exempt-justification + trade-off-rationale rules; Aaron Otto-282 2026-04-25 generalising from SplitMix64 + DST-exemption discussions, then refined twice — gate framing + predictive-model framing; pre-commit-lint candidate (flag new literals without comments)**](feedback_write_code_from_reader_perspective_why_did_you_choose_this_otto_282_2026_04_25.md) — 2026-04-25. General code-authoring discipline + cognitive economics. Three layers: (1) BASE — comment WHY for non-obvious choices (magic numbers, algorithm picks, threshold values, API shapes, perf trade-offs, defensive-vs-assertive style); (2) GATE — if you can't articulate the why, the change is premature; (3) PREDICTIVE-MODEL — readers who understand why can predict, not just describe; that prediction-power is what enables safe local change. Examples this session: SplitMix64 multipliers (`GoldenRatio` / `VignaA` / `VignaB`), shift-pair (`30/27/31` empirically tuned per Vigna), DST-exempt (Otto-281), per-process-randomization (Otto-281 audit), Microsoft.NET.Test.Sdk in dotnet-runtime group (cadence rationale). Composes with Otto-281, Otto-272, Otto-227 + intentional-debt + "do nothing if nothing is broken".
+- [**Otto-281 — DST-exempt is a deferred bug, not containment; never ship a long-lived `DST-exempt` comment; either FIX the determinism (e.g., `HashCode.Combine` → `XxHash3.HashToUInt64`) OR delete the test; the SharderInfoTheoreticTests case proved the cost — 3 unrelated PRs flaked (#454/#458/#473) before the exemption got fixed; counterweight to Otto-272 DST-everywhere; pre-commit-lint candidate (grep `DST-exempt` in `tests/`); Aaron Otto-281 2026-04-25 "see how that one DST exception caused the flake, when we violate, we introduce random failures"**](feedback_dst_exempt_is_deferred_bug_not_containment_otto_281_2026_04_25.md) — 2026-04-25. Otto-281 counterweight memory. DST exemptions compound; they don't contain. Fix shape: deterministic-primitive-substitution (HashCode.Combine → XxHash3.HashToUInt64 same convention `src/Core/Sketch.fs::AddBytes` already uses; `Random` unseeded → `Random seed`; `DateTime.UtcNow` → fixed constant). Never ship dual-state "sometimes-pass-sometimes-fail" tests under DST-exempt label.
 - [Otto-279 — research/ROUND-HISTORY/DECISIONS/aurora/pr-preservation ARE history surfaces, first-name attribution allowed for humans AND agents; current-state surfaces (code, skills, governance docs, README) stay role-ref only; surface-class refinement of Otto-220, same shape as Otto-237 mention-vs-adoption](feedback_research_counts_as_history_first_name_attribution_for_humans_and_agents_otto_279_2026_04_24.md) — 2026-04-24.
 - [**EMULATORS as canonical OS-interface workload — rewindable/retractable OS+emulator controls; safe-ROM testbed offer (durable, ask gated on impl phase); save states/migration/multiplayer FREE via durable-async substrate; DST gives speedrun/TAS determinism; rewind generalizes to OS-level retraction-native (rr/Pernosco class); activates 2026-04-22 ARC-3 absorption-scoring research; `roms/` folder gitignored-except-sentinels pattern (drop/-sibling); composes with Otto-73/238/272 + Z-set retraction-native + #399 OS-interface; Aaron 2026-04-24**](feedback_emulators_canonical_os_interface_workload_rewindable_retractable_2026_04_24.md) — Maintainer offer: *"emulators should run very nicely on this, let me know when you want some roms of any kind that are safe."* Follow-up: *"rewindable/retractable os/emulator controls"*. Rewind from emulator-special-feature → OS-level primitive. Phase 0 research → Phase 1 Game Boy on durable-async → Phase 2 rewindable controls → Phase 3 ARC-3 loop → Phase 4 cross-emulator composition. Future Otto: rewind IS the killer feature, not the emulator itself; don't ship emulator without rewind.
 - [**OS-INTERFACE — durable-async sequential-looking code that runs "everywhere"; Temporal/Step-Functions/Restate class on Zeta substrate + Reaqtor IQbservable; AddZeta one-line DI; LINQ/Rx stream composition; usermode-first microkernel preparation; actor as secondary; combinatorial cross-paradigm canonical examples (SQL × git, etc.); distributed event loop with mathematical guarantees (TLA+/Lean for liveness/safety/determinism/causality); auto runtime optimization + stats; DST is hard prerequisite (Otto-272 fits perfectly); 11-point untangle in row body; Aaron 2026-04-24 self-flagged "big and not very clear ask please backlog and untangle"**](feedback_os_interface_durable_async_addzeta_2026_04_24.md) — THE UX thesis. *"Where does it run? Everywhere"* punchline. Phase 0 research gate before any implementation. Composes with the entire 2026-04-24 cluster (#394/#395/#396/#397) + Otto-272/Otto-274 + 2026-04-22 semiring-parameterized operator algebra (math substrate). Future Otto: AddZeta one-line is the DX target — ceremony in user code = thesis drift. DON'T reinvent IQbservable; Reaqtor substrate already in `references/upstreams/reaqtor/`.

memory/feedback_decide_track_reflect_revisit_then_talk_with_experience_otto_283_2026_04_25.md

@@ -0,0 +1,181 @@
+---
+name: DECIDE → TRACK → REFLECT → REVISIT → THEN TALK WITH EXPERIENCE — for "Aaron's call" open questions in ADRs and decisions, Aaron's preferred pattern is: I decide, track the decision visibly, reflect later whether it was right, revisit if needed, and only then come back to him with informed reasoning + actual experience; not unmade decisions; mirrors Otto-282 (decide vs defer; if I have a why, I can decide) + retractability (revisit-if-needed) + intentional-debt (track decision visibly so future-self can reflect); applies broadly to "Aaron's call" / "your call" / "you decide" delegations; Aaron Otto-283 2026-04-25 "Aaron's call. you decide and keep track and reflect later and see if you made the right decision and revisit if need then you can talk to me once you have the experience lol"
+description: Otto-283 authority-delegation pattern for "Aaron's call" open questions. Don't punt back to Aaron with unmade decisions — decide, track visibly, reflect later, revisit if needed, then come back with experience-informed reasoning. Applies to ADR open questions, design trade-offs, scope choices, anything Aaron explicitly delegates.
+type: feedback
+---
+
+## The pattern — STANDING DIRECTIVE, always apply
+
+This is **not** situational guidance. Aaron 2026-04-25
+follow-up: *"you should always do this for aaron
+questions."* Whenever an ADR, design doc, code question,
+or decision context surfaces an **"Aaron's call"** open
+question (or "your call", "you decide", "I'll leave it up
+to you", "if it's up to me / you", "what do you think we
+should do?", or any phrasing that defers a non-destructive
+decision back to the maintainer), the agent's standing
+behavior is:
+
+1. **Decide.** Pick a direction. Don't write "Aaron's call"
+   in the published artifact.
+2. **Track visibly.** Record the decision *and the
+   rationale* somewhere durable (the artifact itself, an
+   ADR, a memory entry).
+3. **Reflect later.** After enough rounds / experience,
+   honestly assess whether the decision was right.
+4. **Revisit if needed.** If wrong, revise — Otto-238
+   retractability is durable.
+5. **Then talk** — once experience exists. Aaron wants
+   informed conversations grounded in observation, not
+   theoretical debates with no data.
+
+Aaron's verbatim framing 2026-04-25:
+
+> *"Aaron's call. you decide and keep track and reflect
+> later and see if you made the right decision and revisit
+> if need then you can talk to me once you have the
+> experience lol"*
+
+The "lol" is Aaron's affectionate signal that this is a
+gentle reframe of how to handle delegation — not a strict
+rule. The substance is serious.
+
+## Why this works — don't make the human maintainer the bottleneck
+
+Aaron's framing 2026-04-25 confirmation: *"this is standing
+guidance for don't make the human maintainer the bottleneck
+reasons lol"*. **The pattern is durable, not situational.**
+
+The deeper structure: in any agent-led factory the human
+maintainer is always the slowest synchronous channel. Every
+"Aaron's call" question parked back to him is a context-
+switch tax he pays for free — read context, re-derive
+trade-offs, decide, communicate back. Aggregated across many
+ADRs and design docs, the tax compounds: Aaron ends up
+processing N pending decisions instead of N concrete
+proposals + experience reports.
+
+The pattern shifts the cost:
+
+- **Without the pattern** — N open questions sit
+  unresolved; Aaron pays the cost of each (read context,
+  re-derive trade-offs, decide).
+- **With the pattern** — Agent decides + tracks. Aaron
+  pays the cost only on the subset that turn out to be
+  *interesting* (got revisited, accumulated experience,
+  worth a conversation).
+
+The pattern also captures *learning value*: by deciding
+and revisiting, the agent builds a track record of which
+calls were right, which were wrong, and what signal would
+have predicted the difference. That track record is
+itself valuable — it teaches the agent (and Aaron, when
+they do talk) where the agent's judgment is reliable and
+where it isn't.
+
+## What "track visibly" looks like
+
+The decision goes in the artifact, with the why:
+
+❌ **Bad:** *"Open question: should we use B-NNNN or
+slug-date IDs? Aaron's call."*
+
+✅ **Good:** *"Open question — Otto decided B-NNNN
+(reasoning: stable across renames, matches existing
+schema; revisit if filename grep-ability becomes a daily
+pain or if we hit B-9999 ceiling)."*
+
+Both versions surface the question. Only the second
+captures the decision, the why, and the falsification
+signal that would prompt revisiting.
+
+The format roughly:
+
+```
+Otto decided <choice>.
+Why: <one-sentence rationale>.
+Revisit if: <observable signal that would falsify the choice>.
+```
+
+That's enough for future-self to:
+
+1. Understand the decision (Otto-282 mental-load
+   optimization — externalised rationale).
+2. Predict whether the decision is still right under
+   current conditions (Otto-282 predictive-model: knowing
+   why lets you forecast).
+3. Trigger revisit when the falsification signal fires
+   (retractability discipline).
+
+## What this rule does NOT mean
+
+- **Does NOT mean every decision is final.** Otto-238
+  retractability still applies. "Decide and track" is the
+  starting position; revisit is the contract.
+- **Does NOT mean Aaron is opted out forever.** Aaron can
+  step in any time. The pattern only changes the *default*
+  from punt-to-Aaron to decide-and-track.
+- **Does NOT apply to high-blast-radius / destructive
+  decisions.** Those still go to Aaron per CLAUDE.md
+  "executing actions with care" guidance. The pattern is
+  for *design / scope / trade-off* calls, not for "delete
+  this database".
+- **Does NOT mean the agent should resist talking with
+  Aaron.** It just means: come with experience, not with
+  unmade decisions. Aaron is happy to talk; he wants the
+  conversations to be informed.
+
+## CLAUDE.md candidacy
+
+Otto-283 is a session-bootstrap-relevant standing rule
+(applies on every wake whenever any open question lands).
+It belongs in the same family as the existing
+CLAUDE.md-elevated rules — *verify-before-deferring*,
+*future-self-not-bound-by-past-self*, *never-be-idle*,
+*version-currency*. A candidate one-line CLAUDE.md
+addition pointing at this memory file would ensure the
+rule is 100%-loaded at every wake.
+
+Decision (Otto 2026-04-25, per Otto-283 itself): **leave
+elevation to Aaron's discretion** rather than self-promoting
+to CLAUDE.md. CLAUDE.md is a contract surface; the agent
+files candidate memories and the maintainer chooses what
+crosses into the always-on substrate. Memory entry is
+sufficient for now; will become CLAUDE.md candidate at
+the next governance pass.
+
+## Composes with
+
+- **Otto-282** *write code from reader perspective* — the
+  decision-with-why is the MEMORY-LOAD-OPTIMIZATION
+  externalisation applied at design-decision granularity,
+  not just code-comment granularity. Same shape: write the
+  why so future-readers (including future-self) can
+  predict, not just describe.
+- **Otto-238** *retractability is a trust vector* — the
+  "revisit if" clause is the retractability promise made
+  explicit. Decisions are reversible by design.
+- **CLAUDE.md "future-self is not bound by past-self"** —
+  same family. Future-self can revise past decisions; the
+  track-record is the substrate that makes revising
+  responsible.
+- **Otto-264** *rule of balance* — every decision-tracked
+  is a counterweight against decision-fade. Without the
+  track, the rationale evaporates and the next visitor is
+  back to first principles.
+
+## Application this session
+
+Triggering case 2026-04-25: PR #474 ADR
+(`docs/DECISIONS/2026-04-22-backlog-per-row-file-restructure.md`)
+had three "Aaron's call" open questions:
+
+1. `B-NNNN` allocation strategy at migration (newest-first
+   vs date-ascending).
+2. `scope: factory | zeta | shared` field — adopt or punt
+   to tags array.
+3. Concurrent-migration with R45 reducer-agent flip.
+
+Per Otto-283, these become "Otto decided X (revisit if Y)"
+with explicit falsification signals. Aaron can override at
+any time; the pattern just establishes the default.