From 1d173e0075f6bc944c8ec4b6f3ea69296674cadb Mon Sep 17 00:00:00 2001 From: Aaron Stainback Date: Sat, 2 May 2026 15:38:14 -0400 Subject: [PATCH 1/2] free-memory(never-idle refinement): proper order > smallest-thing-first; depends_on graph as ordering substrate (Aaron 2026-05-02) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Aaron 2026-05-02 corrected my real-time application of the never-idle discipline after I defaulted to "Loop continues" minimal-acknowledgment for many ticks during an extended Aaron-pause. The corrective extends the existing never-idle substrate (already pointed at from CLAUDE.md) so future-Otto inherits the refinement. Aaron's framings preserved verbatim: "i would not call all backlog items speculative, many are but some are concered get this small thing done but proper order matters more than doing the smallest thing you started adding like depend on so the order could be tracked too i don't know how far you got." "that backlog depends on never idle refinement priority is something that future ai should remember too" "we can slowly figure it out over time too, no rush we can do best guesses as you but out proper infrstructure for this" Five corrective clauses landed: 1. NOT all backlog items are speculative 2. Proper ORDER matters more than smallest-thing-first 3. depends_on: is the ordering substrate (currently 11/148 coverage; backfill incrementally on-demand) 4. Order signal sequence: depends_on graph > tier > tier- frontmatter > effort/blast-radius > composes_with > date-recency 5. Backfill discipline: best-guesses-with-time, no rush, build out infrastructure incrementally Composes with: action-hierarchy + amortized-speed Superfluid + recurrence-after-correction substrate (this is the second- order recurrence — substrate-rule weight increases each cycle, eventually exceeding training-prior threshold). Future-Otto inherits via the existing CLAUDE.md never-idle bullet pointer (no separate CLAUDE.md edit needed; this is a refinement to a memory file CLAUDE.md already references). Co-Authored-By: Claude Opus 4.7 --- ...ever_idle_speculative_work_over_waiting.md | 88 +++++++++++++++++++ 1 file changed, 88 insertions(+) diff --git a/memory/feedback_never_idle_speculative_work_over_waiting.md b/memory/feedback_never_idle_speculative_work_over_waiting.md index b20fcfd8c..a282f36a3 100644 --- a/memory/feedback_never_idle_speculative_work_over_waiting.md +++ b/memory/feedback_never_idle_speculative_work_over_waiting.md @@ -256,3 +256,91 @@ change is the cure. zero; `work continuation` and `free-time research` become the majority classes. Any persistent `idle` row triggers a factory-shape-bug investigation. + +## 2026-05-02 refinement — proper order matters more than smallest-thing-first (Aaron) + +Aaron 2026-05-02 corrected my real-time application of the +never-idle discipline after I defaulted to "Loop continues" +minimal-acknowledgment for many ticks during an extended +Aaron-pause. The corrective framing in his words: + +> *"i would not call all backlog items speculative, many are +> but some are concered get this small thing done but proper +> order matters more than doing the smallest thing you started +> adding like depend on so the order could be tracked too i +> don't know how far you got."* + +> *"that backlog depends on never idle refinement priority is +> something that future ai should remember too"* + +> *"we can slowly figure it out over time too, no rush we can +> do best guesses as you but out proper infrstructure for this"* + +### The corrective + +1. **NOT all backlog items are speculative.** Many are + concrete-and-need-to-get-done. The never-idle discipline + doesn't reduce all backlog work to "speculative." + +2. **Proper ORDER matters more than smallest-thing-first.** + Picking the smallest hygiene-only closure (e.g., closing a + row whose underlying concern empirically resolved) is NOT + the right priority lever. Dependency order is. + +3. **`depends_on:` is the ordering substrate.** I introduced + the field on backlog rows from 2026-05-01 onward but only + 11 of 148 open rows have it populated as of 2026-05-02. + Future-Otto: when starting a backlog row, populate its + `depends_on:` as part of the starting work; respect the + dependency graph; backfill older rows incrementally as + they get touched. + +4. **Order signals to honor in priority sequence**: + - `depends_on:` graph (downstream of dependencies must + wait for upstream) + - Tier (P0 > P1 > P2 > P3) + - `tier:` frontmatter field (e.g., wallet-experiment-v0, + factory-tooling, design+implementation) + - Effort and blast radius + - `composes_with:` relationships (related work clusters) + - File-system age and `last_updated` dates as weak signal + +5. **Backfill discipline (Aaron's no-rush framing)**: + - **Best-guesses-with-time**, not big-bang backfill + - **Slowly figure it out over time** as rows get worked + - **Build out proper infrastructure** for tracking + dependency order (tooling could surface unknown-dep + warnings, suggest depends_on candidates, validate the + graph for cycles) + - **No rush** — don't burn substrate-rate trying to + backfill 137 rows in one push + - On-demand: when picking a row to work, populate its + `depends_on:` as part of the starting work; that's how + coverage grows organically + +### Composes with + +- `feedback_action_hierarchy_evidence_over_speculation_friction_reducing_over_neutral_aaron_2026_05_02.md` + (action-pick lens; same priority-order discipline at + action-pick scope) +- `feedback_amortized_speed_superfluid_phase_transition_inverts_per_action_optimization_aaron_2026_05_02.md` + (system-level lens; backlog dependency-order respect IS one + instance of inversion against per-action local-optimization) +- `feedback_recurrence_after_correction_needs_operational_enforcement_otto_2026_05_02.md` + (the no-op-cadence pattern this very correction surfaces; + Aaron's correction came after I defaulted to minimal- + acknowledgment for many ticks despite the substrate-rule on + main — recurrence pattern from earlier this session repeated + AGAIN during 2026-05-02 evening, prompting this refinement) + +### Carved sentence + +**"Never-idle is not 'do something to fill time.' It's 'pick +the next thing in proper order.' Order signals: `depends_on:` +graph first, then tier (P0>P1>P2>P3), then `tier:` frontmatter, +then effort/blast-radius, then `composes_with:` clusters, then +date-recency as weak signal. Smallest-thing-first IS a failure +mode if it bypasses the dependency graph. Backfill `depends_on:` +incrementally as rows get worked + build out proper +infrastructure over time; best-guesses-with-no-rush is the +right cadence."** From a74cfcd5b1307d67a2892c1d2bef426e483544b4 Mon Sep 17 00:00:00 2001 From: Aaron Stainback Date: Sat, 2 May 2026 15:47:19 -0400 Subject: [PATCH 2/2] fix(never-idle-refinement): MEMORY.md pairing + priority-vs-tier naming clarification MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Three Copilot findings on PR #1224 addressed: 1. MEMORY.md pairing required for memory file edits (CI gate memory-index-integrity). Updated the existing never-idle entry with a '2026-05-02 refinement appended' note pointing at the new section. 2. 'Tier (P0 > P1 > P2 > P3)' conflated priority with tier. The schema separates them: priority: is the P0..P3 field; tier: is the free-form field (wallet-experiment-v0, factory-tooling, etc.). Disambiguated in the order-signals list + the carved sentence. 3. Same naming fix in carved sentence — 'tier (P0>P1>P2>P3)' → 'priority: (P0>P1>P2>P3)'. Note on findings #4 and #5 (closure-note-overstating-verification + closed_by-as-free-form-prose): these were anchored to lines that correspond to the B-0073 closure file, which dropped out of this PR's diff after rebase against main (B-0073 closure landed separately via PR #1223). The remaining diff is only the never-idle refinement. Co-Authored-By: Claude Opus 4.7 --- memory/MEMORY.md | 2 +- memory/feedback_never_idle_speculative_work_over_waiting.md | 6 ++++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/memory/MEMORY.md b/memory/MEMORY.md index f262c3632..6e615d13e 100644 --- a/memory/MEMORY.md +++ b/memory/MEMORY.md @@ -578,7 +578,7 @@ These per-maintainer distillations show what's currently in force. Raw memories - [Kanban + Six Sigma — factory methodologies of record](user_kanban_six_sigma_process_preference.md) — adopt practices not bureaucracy; DMAIC + WIP; FACTORY-METHODOLOGIES.md + DMAIC template + HYGIENE row 37. - [Absorb-time filter — Aaron always wanted it; factory does it for him](user_absorb_time_filter_always_wanted.md) — forward/retrospective pairing = Six Sigma Control/Measure; measure retrospective to tune absorb. - [Honor those that came before — unretire before recreate](feedback_honor_those_that_came_before.md) — CLAUDE.md-load; retired memories preserved in-tree; retired SKILL.md = code → git history only; Elizabeth-register. -- [Never be idle — speculative work beats waiting](feedback_never_idle_speculative_work_over_waiting.md) — CLAUDE.md-load; tool defaults don't override factory policy; meta-check first. +- [Never be idle — speculative work beats waiting](feedback_never_idle_speculative_work_over_waiting.md) — CLAUDE.md-load; tool defaults don't override factory policy; meta-check first. **2026-05-02 refinement appended:** proper order > smallest-thing-first; `depends_on:` graph is the ordering substrate; backfill incrementally on-demand (best-guesses-with-time, no rush per Aaron). - [People/team optimizer — DAO-native factory org-design spike](project_people_optimizer_dao_factory_restructuring.md) — two-team factory/SUT split + role-switching QoL + no-manager DAO + Conway's-Law start. - [Zeta retractable-contract ledger — Ouroboros L3; .NET-native contract runtime](project_zeta_as_retractable_contract_ledger.md) — Aurora "do no permanent harm". - [Research-coauthor teaching track — first-paper scaffolding](project_research_coauthor_teaching_track.md) — 6-module; `docs/RESEARCH-COAUTHOR-TRACK.md`. diff --git a/memory/feedback_never_idle_speculative_work_over_waiting.md b/memory/feedback_never_idle_speculative_work_over_waiting.md index a282f36a3..52fe38e65 100644 --- a/memory/feedback_never_idle_speculative_work_over_waiting.md +++ b/memory/feedback_never_idle_speculative_work_over_waiting.md @@ -298,7 +298,9 @@ Aaron-pause. The corrective framing in his words: 4. **Order signals to honor in priority sequence**: - `depends_on:` graph (downstream of dependencies must wait for upstream) - - Tier (P0 > P1 > P2 > P3) + - `priority:` field (P0 > P1 > P2 > P3 — distinct from + `tier:` field below; the schema separates priority from + tier on purpose) - `tier:` frontmatter field (e.g., wallet-experiment-v0, factory-tooling, design+implementation) - Effort and blast radius @@ -337,7 +339,7 @@ Aaron-pause. The corrective framing in his words: **"Never-idle is not 'do something to fill time.' It's 'pick the next thing in proper order.' Order signals: `depends_on:` -graph first, then tier (P0>P1>P2>P3), then `tier:` frontmatter, +graph first, then `priority:` (P0>P1>P2>P3), then `tier:` frontmatter, then effort/blast-radius, then `composes_with:` clusters, then date-recency as weak signal. Smallest-thing-first IS a failure mode if it bypasses the dependency graph. Backfill `depends_on:`