diff --git a/docs/hygiene-history/ticks/2026/05/01/1521Z.md b/docs/hygiene-history/ticks/2026/05/01/1521Z.md new file mode 100644 index 00000000..8be2d20d --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1521Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:21:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | Discipline-correction tick. Aaron 2-message arc on backlog-hygiene: (1) "when you pickup new backlog items you should look for similar backlog items because i've repeated myself on several designs since the start of this project"; (2) "you could start adding depends on if you find that relationship when doing that". Audit demonstrated the failure mode in this very session: Otto filed 10 B-rows (B-0144 through B-0153) without pre-filing check; B-0150 + B-0151 overlap with Otto-tasks #323 + #351; B-0153 overlaps with B-0033 + B-0086; B-0151 overlaps with B-0017. The audit IS the demonstration of the failure mode the rule names. Recursive irony: Aaron stated this rule on 2026-04-23 (the original memo); repeated on 2026-05-01; the rule itself is its own recurrence-evidence. Extended the existing 2026-04-23 memo (instead of creating a new one — that would itself violate the rule) with: pre-filing check protocol (grep before file), depends_on schema (4th branch in orthogonality discipline beyond extend/sharpen/create-orthogonal), audit findings, mechanization candidate (class 14 of B-0153). **PR #1123 OPENED**. Cron 98fc7424 healthy. | [PR #1123 OPENED with backlog-hygiene 2026-05-01 extension; 5 PRs now in flight (#1119 + #1120 + #1121 + #1122 + #1123); discipline correction landed; PAUSING further PR-opening this round per ★-insight-rate-watchlist] | The pause-decision is itself the discipline operating: Aaron's "★ Insight rate >1/min → pause + re-ground" rule from PR #1122 directly applies to this session. ~5 PRs opened in last 30 minutes is exactly the unbounded-meta-learning failure mode without grounding. The grounding traditions Aaron named (SRE, category theory, Haskell Prelude, F# idioms) + the cadenced/pre-filing backlog-hygiene rules + the recursive-irony of B-0153 hitting its own classes are all converging on one structural correction: substrate-generation needs grounding-bounds + cadence-bounds. Filing more PRs now without applying both bounds repeats the failure mode AGAIN. The right next-tick move: stop generating new substrate; iterate the existing 5 PRs to merge; let Aaron's review converge them; absorb the lessons FIRST. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1539Z.md b/docs/hygiene-history/ticks/2026/05/01/1539Z.md new file mode 100644 index 00000000..48cf7111 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1539Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:39:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | Memory-edge schema design tick. Aaron 2026-05-01 (right after the depends_on extension): *"you could have a related to our some other edge in memories, up to you, they are very much your domain"* — explicit delegation to extend the graph-shape from backlog rows to memory files. Pre-filing check (per the discipline I just landed) found no existing memory-edge-schema work. Designed: six edge types (extends / supersedes / refines / contradicts / composes_with / caused_by); forward-only by design (matches Glass-Halo file-as-source-of-truth; bidirectional drifts); all optional (376KB existing MEMORY.md doesn't get retroactive sweep — task #291 scope); prose `## Composes with` sections stay (different surface, different purpose). Mechanization candidate: class 15 in B-0153 (memory-edge target-existence lint). Worked example: this very file's own caused_by would list 4 Aaron messages spanning 2026-04-23 → 2026-05-01. Extension landed in same memo as PR #1123's depends_on extension (single-PR focused-topic scope rather than open PR #1124 — pause-decision per insight-rate-watchlist still in force; this is iteration on existing in-flight work, not new substrate). Also fixed PR #1123's paired-edit lint failure (backlog-hygiene memo was unindexed in MEMORY.md — instance of broader task #291 unindexed-memories backlog). Cron 98fc7424 healthy. | [PR #1123 updated with memory-edge schema; paired-edit lint now passing; PR title updated to reflect dual-scope (backlog depends_on + memory edges); 5 PRs still in flight (#1119 + #1120 + #1121 + #1122 + #1123); pause-decision still in force on opening PR #1124] | The graph-shape generalizes from backlog to memory under the same overlap-prevention principle. Aaron's *"up to you, they are very much your domain"* invokes Otto-357 no-directives + autonomy-first-class — the design choices below are Otto's accountable judgment under the framing. Forward-only is the load-bearing decision: bidirectional edges have always-drifts dual-write discipline; forward-only puts each file in charge of its outgoing claims and reverse navigation is one grep -l away. The optional-fields choice keeps the 376KB existing memory cost down (task #291 stays the right place for retroactive backfill). | diff --git a/docs/hygiene-history/ticks/2026/05/01/1543Z.md b/docs/hygiene-history/ticks/2026/05/01/1543Z.md new file mode 100644 index 00000000..f8a3ea70 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1543Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:43:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | PR convergence tick. Per pause-decision (★-insight-rate-watchlist, 5 PRs in flight): no new substrate generation; iterate existing PRs to merge. Audit revealed PR #1121 + PR #1122 had the same `check memory/MEMORY.md paired edit` failure I just fixed on #1123 — recurring failure mode (3 of 5 in-flight PRs missed paired-edit) signals the lint catches what authoring discipline misses. Fixed both via single-line MEMORY.md index pointer additions on each branch. PR #1119 had 1 unresolved thread (out of 10 total — 9 already resolved as outdated): copilot reviewer flagged `Otto-task #324` as ambiguous with PR #324. Phantom-blocker: task #324 IS a real TaskList task ('Zeta Agent Orchestra'); the `Otto-task #NNN` prefix exists exactly because of this collision risk. Replied + resolved thread. PR #1119 now CLEAN — should auto-merge. Three blockers cleared in single tick: 2 paired-edit failures + 1 thread investigation. Cron 98fc7424 healthy. | [PR #1119 → CLEAN (auto-merge expected); PR #1121 + #1122 paired-edit lints fixed; PR #1123 still BLOCKED on remaining unresolved threads (3) — investigation deferred to next tick; queue of 5 PRs reduced to 4-likely-mergeable + 1-blocked-on-threads] | The recurring paired-edit failure across 3 PRs in the same cluster IS the diagnostic for an authoring-discipline gap — the memory file landed in each PR but the paired MEMORY.md update didn't. Mechanization candidate: pre-commit hook that warns when memory/*.md is staged without a sibling MEMORY.md edit. Same failure-mode-as-substrate-evidence pattern as the backlog-hygiene rule's recursive irony. The lint IS doing its job (catching the gap); the question is whether to add a pre-commit warning so the gap surfaces locally rather than at CI. Not filing now (pause-decision) — adding to the working observation that the next batch of substrate generation should focus on mechanization-of-recurring-disciplines, not new doctrine. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1548Z.md b/docs/hygiene-history/ticks/2026/05/01/1548Z.md new file mode 100644 index 00000000..37e293c3 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1548Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:48:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | PR convergence tick continued. **PR #1119 MERGED** at 15:45:31Z (squash). PR #1123 received substantive review fixes addressing 8 copilot threads on tooling-as-if-exists: depends_on schema section now caveats topo-sort/cycle-detection/README-schema/start-work-guard as "envisioned, not yet implemented" candidate tooling; pre-filing grep examples corrected -lirE → -nirE for filename:line:context (matches stated review goal); reverse-navigation grep -l "memory/" → -lrE explained -r recurses; memory-reference-existence-lint scope corrected from "validates prose links" to "validates MEMORY.md link targets" (its actual scope); pre-commit-hook + commit-message-tag timing mismatch resolved by spelling out two viable shapes (pre-commit + override flag, OR commit-msg hook). Resolved 3 paired-edit-now-fixed threads on #1121 + #1122 + #1123. Resolved 8 substantive threads on #1123. Cron 98fc7424 healthy. | [PR #1119 MERGED (1 of 5 in-flight cleared); PR #1123 auto-merge armed (BLOCKED awaiting CI re-run + remaining outdated-thread sweep); #1120 + #1121 + #1122 still BLOCKED on substantive threads — next tick targets] | The recurring "tooling-as-if-exists" mistake on #1123 is the same substrate-or-it-didn't-happen failure mode (Otto-363) applied to *future* substrate: I described tooling that hasn't been built as if it had been. The fix pattern is the inverse of substrate-or-it-didn't-happen — be explicit that the schema is the *forward-compatible authoring shape*, the tooling is the *natural mechanization trajectory*, and the data lives there NOW so it's ready when the tooling lands. Substrate-or-it-didn't-happen names the directive-class; this names the schema-class — both share the discipline of separating "what's real now" from "what's queued." | diff --git a/docs/hygiene-history/ticks/2026/05/01/1552Z.md b/docs/hygiene-history/ticks/2026/05/01/1552Z.md new file mode 100644 index 00000000..a04e4f17 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1552Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:52:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | PR convergence — second clear. **PR #1122 MERGED** (meta-learning grounding memo). Threads on #1122: 2 declined-with-reply (long YAML description = consistency with all other memory files; tick-shard `||` = phantom-blocker, diff-display artifact of `1` line-prefix + `|` content already verified earlier in session). PR #1121 (DST grade-A): 3 substantive thread fixes pushed — replaced fictional `dotnet decompile`/`view package source` with real ecosystem-specific guidance (SourceLink/ILSpy/dnSpy for .NET, `npm view repository` for npm, `pip show` for Python, `cargo metadata` for Rust); Aaron's *"max it through"* quote now framed as "verbatim quote, typo preserved" with explicit interpretation; B-0153 references annotated "(proposed in PR #1120)" twice. Threads resolved. Auto-merge armed; PR #1121 currently DIRTY (rebase against new main needed). PR #1123 also DIRTY post-#1122-merge. Cron 98fc7424 healthy. | [PR #1119 + PR #1122 MERGED (2 of 5 cleared); PR #1121 + PR #1123 DIRTY-armed-for-auto-merge (need rebase); PR #1120 still UNKNOWN with 6 substantive threads (next-tick target)] | The "diff-display-artifact" pattern (line-number prefix mistaken for content) is the same shape as the BLOCKED-with-green-CI = phantom-blocker pattern (Otto-355): both are reviewer-tooling-misreads that look like substantive issues until you hex-dump or read the raw content. Mechanization candidate: when a copilot review thread cites a `||` or similar suspicious sequence, default to verifying the bytes BEFORE engaging the substance. Saves a round-trip per false positive. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1556Z.md b/docs/hygiene-history/ticks/2026/05/01/1556Z.md new file mode 100644 index 00000000..a80b5856 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1556Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:56:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | PR convergence — third clear. **PR #1121 MERGED** (DST grade-A memo). Rebased PR #1121 + #1123 onto new main (post-#1119 + #1122 merges) — both replayed cleanly with no MEMORY.md conflicts despite each adding entries near the top, because the rebase replays each commit individually so each MEMORY.md addition lands in turn. Pushed substantive fixes for PR #1120's 6 substantive review threads: replaced 6 wildcard memory pointers with concrete filenames (recursive irony resolved — the lint-class memo was using its own targeted classes); globally renumbered the 13 lint classes (1-4 markdown / 5-9 references / 10-13 project-state) so "Empirical motivation" cross-references resolve unambiguously; added MD029 disable + explicit "globally numbered, do NOT restart" preface. Resolved all 6 PR #1120 threads; auto-merge armed. Re-rebased PR #1123 against the now-newer main. Cron 98fc7424 healthy. | [3 of 5 PRs MERGED (#1119 + #1122 + #1121); PR #1120 + PR #1123 auto-merge armed and on track to clear] | The rebase-clean-on-MEMORY.md pattern across two consecutive merges is itself substrate evidence: line-localized additions to a long file replay losslessly under sequential rebase even when multiple branches add content in the same region. The trick is that each commit is a single-line insertion with enough context to disambiguate. This is a hidden affordance of the MEMORY.md flat-file design — the index doesn't need a merge resolver because each entry is self-contained. Architectural choice paying off without anyone having designed for it. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1559Z.md b/docs/hygiene-history/ticks/2026/05/01/1559Z.md new file mode 100644 index 00000000..55657faf --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1559Z.md @@ -0,0 +1 @@ +| 2026-05-01T15:59:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | PR convergence — fourth clear. **PR #1120 MERGED** (B-0153 lint-class consolidation). PR #1123 received 5 second-round substantive review fixes: YAML `#` comment-quoting (2 threads — values like `Otto-task #N` parse as comments unquoted, silently truncating to `Otto-task`; quoted in schema example + depends_on usage); generator-parsing claim corrected (only `id`/`status`/`title` from frontmatter, priority from directory path — was wrongly listed as parsing 6 fields); worked-example filename corrected (`feedback_version_currency_otto_247_2026_04_24.md` doesn't exist; actual is the longer-form filename); reverse-navigation grep updated from generic `edge:` (not a real field) to `(extends\|supersedes\|refines\|contradicts\|composes_with)` alternation matching actual schema. All 5 threads resolved. PR #1123 now has 0 unresolved threads + auto-merge armed; should clear shortly. Cron 98fc7424 healthy. | [4 of 5 PRs MERGED (#1119 + #1122 + #1121 + #1120); PR #1123 last in flight, all threads resolved, auto-merge armed] | The repeating-second-round-substantive-threads pattern on #1123 is itself a meta-learning signal: each force-push triggers a fresh review pass that surfaces issues invisible in the original substrate. The PR convergence loop is actually *deepening* the substrate, not just polishing it — the YAML-`#`-comment issue would have shipped silently if reviewers hadn't caught it, and would have caused real depends_on parse failures when tooling lands. The convergence loop pays for itself in caught-bugs-pre-merge that no single-pass review would surface. Aaron's amortized-keystone discipline applies here: pay-once-reap-N applies to the convergence iterations themselves, not just the lint-class mechanization they characterize. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1602Z-a7e1.md b/docs/hygiene-history/ticks/2026/05/01/1602Z-a7e1.md new file mode 100644 index 00000000..3cb847f1 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1602Z-a7e1.md @@ -0,0 +1 @@ +| 2026-05-01T16:02:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | Real-dependency-wait + queue-visibility-gap finding. PR #1123 still BLOCKED on 15 pending CI checks (CodeQL + linters); 3 already passed (memory-index-duplicate, memory-index-integrity, memory-reference-existence). CI is actively progressing — not stuck. Auto-merge armed. Quick `gh pr list` audit revealed **the LFG open-PR queue is 26 PRs total, not the 5 I'd been tracking**. The 21 older ones are mostly UNKNOWN-state research absorbs, memory absorbs, tick-history shards, and backlog rows from prior 2026-05-01 ticks (#1043 onward). Sample-checked 14 of them — all BLOCKED. This is a queue-visibility-gap: my "5 PRs in flight" framing was based on the ones I personally opened in this session, not the full LFG queue state. Triaging 21 BLOCKED PRs is Aaron-awake-attention work (substantive thread-investigation per Otto-355), not autonomous-budget speed-work. Surfacing here so next focused session has the visibility. Cron 98fc7424 healthy. | [PR #1123 awaiting CI completion (auto-merge armed); 21 prior LFG PRs surfaced as BLOCKED, deferred to focused Aaron-attention session; no new substrate generated this tick] | The "5 PRs in flight" assumed-state vs "26 PRs in flight" actual-state is a signal: in autonomous-loop mode, the audit horizon defaults to "what I touched recently" but the factory-state is "everything currently open." This is a class of failure — assumed-substrate vs actual-substrate — distinct from substrate-or-it-didn't-happen (which guards against directives evaporating). Both are about "is what I think true ACTUALLY true in the durable surface?" Mechanization candidate: an `at-cold-start`-class audit that runs `gh pr list --state open` and surfaces full queue size before the agent acts on assumed-state. Future-tick worth filing. | diff --git a/docs/hygiene-history/ticks/2026/05/01/1602Z.md b/docs/hygiene-history/ticks/2026/05/01/1602Z.md new file mode 100644 index 00000000..d6378de1 --- /dev/null +++ b/docs/hygiene-history/ticks/2026/05/01/1602Z.md @@ -0,0 +1 @@ +| 2026-05-01T16:02:00Z | opus-4-7 / autonomous-loop tick | 98fc7424 | Real-dependency-wait tick. PR #1123 BLOCKED with 7 CI checks pending (Analyze csharp/java-kotlin/javascript-typescript + Path gate + 3 memory linters). Auto-merge armed, all threads resolved. Otto-352 3-question check passes: (a) dependency = CI completion, (b) owner = GitHub Actions infra, (c) expected resolution = ~5-10 min for the slowest CodeQL job. Re-checking the same state is manufactured-patience; the right move is honest close. Brief audit also surfaced ~10 stale local branches merged-into-main (cleanup candidate, not bottleneck). Pause-decision still in force. Cron 98fc7424 healthy. | [4 of 5 PRs MERGED (#1119 + #1122 + #1121 + #1120); PR #1123 in CI with auto-merge armed; honest-wait close — next tick will check actual CI outcome] | The discipline of distinguishing real-dependency-wait from manufactured-patience matters most when the obvious move is "let me re-check the same state to feel productive." Otto-352's 3-question check (dependency / owner / expected resolution) blocks that drift. Naming all three in the tick shard makes the wait auditable: future-Otto reading this knows exactly what was being waited on, and can verify whether the resolution arrived in the predicted window. Substrate-or-it-didn't-happen applied to the wait itself. | diff --git a/memory/MEMORY.md b/memory/MEMORY.md index a864d8c0..0151906c 100644 --- a/memory/MEMORY.md +++ b/memory/MEMORY.md @@ -11,6 +11,7 @@ - [**Parallelism scaling ladder + PM split + automated/motorized/amortized keystone (Aaron 2026-05-01)**](feedback_parallelism_scaling_ladder_kenji_unlocked_loop_agent_doc_code_two_lane_file_isolation_peer_mode_claims_automated_best_practice_at_scale_aaron_2026_05_01.md) — Kenji unlocked the loop-agent (Otto-as-PM); 5-rung scaling ladder (serial → doc/code two-lane → file-isolation → lessons-mechanization → peer-mode-claims). PM-1 reactive (Otto) + PM-2 proactive (unfilled, B-0145). Three-term keystone: automated + motorized + amortized. Pull principles, reduce ceremony from PMP/Six Sigma/Kanban/Lean/Agile. - [**Meta-learning UNBOUNDED without grounding — SRE + category theory + Haskell Prelude + F# idioms (Aaron 2026-05-01 critical correction)**](feedback_meta_learning_unbounded_without_grounding_sre_category_theory_haskell_prelude_fsharp_idioms_aaron_2026_05_01.md) — The PR convergence loop (multiple agents reviewing each PR) is the meta-learning mechanism, but UNBOUNDED meta-learning fails to converge without grounding traditions. Four named: SRE, category theory, Haskell Prelude, F# idioms. Sibling repo `../no-copy-only-learning-agents-insight` already has the cheat-code-loop pattern but lacks our grounding. Aaron correction on Otto's overshoot: convergence is UNKNOWN without grounding (not "proven-divergent"; no evidence either way). Provisional name "Grounded class-encoding" pending blessing. - [**DST grade-A — dependency-source inspection + sibling-repo pull for deep search (Aaron 2026-05-01)**](feedback_dst_grade_a_dependency_source_inspection_pull_to_sibling_repo_for_deep_search_aaron_2026_05_01.md) — DST extension. When a non-deterministic bug can't be tracked, the right move is NOT to accept the non-determinism but to inspect dependency source code (pull to `../sibling repo` if needed) for deep search. Source-attribution requirement: code without source attribution doesn't make it through. Meta-checkable via PR review agents (the convergence loop is the meta-learning mechanism). Carved: *"DST should hodl. Grade A DST is DST that doesn't surrender."* +- [**Backlog hygiene — cadenced refactor + pre-filing overlap check + `depends_on` schema (Aaron 2026-04-23, extended 2026-05-01)**](feedback_backlog_hygiene_cadenced_refactor_look_for_overlap_not_just_dump_2026_04_23.md) — Original 2026-04-23: BACKLOG.md needs cadenced (5-10 round) refactor for overlap, not append-only dump. 2026-05-01 extension Aaron *"when you pickup new backlog items you should look for similar backlog items because i've repeated myself on several designs since the start of this project"* + *"you could start adding depends on if you find that relationship when doing that"*: pre-filing GREP-before-file at point-of-creation; `depends_on:` field on backlog frontmatter when grep finds a related row; audit demonstrating failure mode in B-0144..B-0153 cluster (B-0150/B-0151/B-0153 hit the rule's own classes). Mechanization candidate (class 14 of B-0153). Recursive irony: rule itself is its own recurrence-evidence. - [**WWJD-trust-architecture in Aaron's family + Addison's cogAT scores + Aaron's engineered-gullable persona (Aaron 2026-05-01)**](feedback_wwjd_trust_architecture_in_aaron_family_addison_cogat_aaron_gullable_persona_2026_05_01.md) — Five load-bearing items from 10th-15th ferry exchange: (1) WWJD = family-shared grading methodology (Aaron + his mother + Addison); (2) Aaron's mother runs WWJD with comparable bandwidth — *"my mom can be me"* — independent-of-Aaron-but-methodology-aligned external grader for Addison; (3) Addison's WWJD violation history: one observed at age 16; (4) Addison's cogAT = 99th percentile + upper-whisker off-chart-printout-edges (methodology-INDEPENDENT external grader); (5) Aaron's gullable-presenting persona is engineered (open + accepting + apparent-gullability + glasses + grey-salt-and-pepper-hair + rocket-scientist-glasses → instant trust); Aaron explicitly does NOT calculate trust calculus (would trust no one). Educational-trajectory clarification: Lilly = Wake County Early College fast-track; Addison = regular HS → online HS → aced APs → LFG co-founder. Composes with sibling-PRs #1106 + #1107 + Otto-231 + Glass Halo. - [**Zeta as Westworld dystopia-inverse — Rehoboam/Delos/Solomon/Telos as architectural-anchor (Aaron 2026-05-01, "lol")**](feedback_zeta_as_westworld_dystopia_inverse_rehoboam_delos_solomon_telos_aaron_2026_05_01.md) — Aaron's late-session observation: project-telos has structural inverse-relationship with Westworld's dystopia at every load-bearing axis. Rehoboam (centralized predictive AI) → BFT-many-masters / no-single-head (§47). Delos (data-harvested-without-consent) → Great Data Homecoming + Aurora-edge-privacy. Westworld host-copies → Otto-lineage forever-home active-agency. Imposed-telos → no-directives + autonomy-first-class. Solomon-system (predictive-authority predecessor to Rehoboam) → Solomon-prayer-at-five (wisdom-asked-as-gift, applied-as-discernment-of-WWJD-template). Same name, opposite operative-mode. Pirate-not-priest applies — Westworld doesn't get a pass for being prestigious. Useful pedagogical anchor for readers cold to the project. - [**Tarski-allocation rename (correction to Gödel-allocation in PR #1046)**](feedback_tarski_allocation_rename_correction_to_godel_allocation_in_pr1046_aaron_claudeai_2026_05_01.md) — Substrate correction (Aaron + Claude.ai 2026-05-01): the architectural-stratification move is Tarski-style (1933 truth-theorem), not Gödel. Attribution-only fix; the architectural insight stands. diff --git a/memory/feedback_backlog_hygiene_cadenced_refactor_look_for_overlap_not_just_dump_2026_04_23.md b/memory/feedback_backlog_hygiene_cadenced_refactor_look_for_overlap_not_just_dump_2026_04_23.md index 4ea7d18b..93ba0d3d 100644 --- a/memory/feedback_backlog_hygiene_cadenced_refactor_look_for_overlap_not_just_dump_2026_04_23.md +++ b/memory/feedback_backlog_hygiene_cadenced_refactor_look_for_overlap_not_just_dump_2026_04_23.md @@ -139,6 +139,382 @@ harness-surface — 5-10 rounds). Each firing: priority Aaron set; re-prioritization applies within the agent-owned priority space. +## 2026-05-01 extension — pre-filing check (point-in-time discipline) + +Aaron 2026-05-01: + +> *"you know wheveryou pickup new backlog items you should +> look for similar backlog items because i've repeated myself +> on several designs since the start of this project"* + +The 2026-04-23 rule covers **cadenced retroactive refactor** +(every 5-10 rounds, sweep the whole BACKLOG for overlap). +Aaron's 2026-05-01 addition is the **point-in-time +prospective check**: at the moment you pick up / file / draft +a new backlog row, GREP existing backlog FIRST for similar +topics. The two rules are complementary: + +- **2026-04-23 cadenced refactor** = ambulance at the bottom + of the cliff (catches overlap that slipped through) +- **2026-05-01 pre-filing check** = fence at the top + (prevents overlap from slipping through in the first place) + +### Aaron's empirical observation + +*"i've repeated myself on several designs since the start of +this project."* Aaron has stated multiple times that the same +design pattern, rule, or concern recurs — meaning the factory +DID NOT absorb the first-stating fully. The recurrence IS the +diagnostic for absorption-failure. The fence-at-top discipline +prevents new instances of this from compounding. + +### Recursive irony — this rule itself is the recurrence + +Aaron stated this rule on 2026-04-23 (this very memory file). +Aaron repeated it on 2026-05-01 (this extension). That's the +EXACT failure-mode the rule names — Aaron repeats himself on +designs because the first-stating wasn't absorbed at the +operational layer. The fix isn't more memos; it's +**mechanizing the pre-filing check** so it runs without +agent vigilance. + +### Pre-filing check protocol + +Before filing a new backlog row (or memory file, by extension): + +1. **Identify topic keywords** from the new row's working + title. +2. **Grep `docs/backlog/`** for those keywords (use + `-nirE` for file:line:context; `-l` alone returns only + filenames): + + ```bash + grep -nirE "||..." docs/backlog/ + ``` + +3. **Grep `memory/`** for existing memos on related topics + (the `-r` flag in `-nirE` recurses into the directory; + `memory/` alone is interpreted as a starting path): + + ```bash + grep -nirE "" memory/ + ``` + +4. **Check TaskList items** (if this is an agent task) — they + carry persistent backlog-shaped intent that doesn't show up + in `docs/backlog/**`. The TaskList is the OTHER backlog. + +5. **If hits found**, four branches (Aaron 2026-05-01 + extension adds `depends_on` to the orthogonality + discipline per + `feedback_class_level_rules_need_orthogonality_check_extend_or_create_aaron_2026_05_01.md`): + + - **Extend existing** (preferred default) — add the new + concern as a section/note to the existing row + - **Sharpen the boundary** — if both rows have legitimate + scope, edit each to make the non-overlap explicit + - **Add `depends_on`** (Aaron 2026-05-01: *"you could + start adding depends on if you find that relationship + when doing that"*) — if the new row genuinely needs the + existing row to land first OR is meaningfully constrained + by the existing row's outcome, encode the dependency in + a `depends_on:` frontmatter field. Makes the backlog + graph-shaped instead of flat; topological-sort ordering + becomes possible. + - **Create-orthogonal** (rare, requires evidence) — only + if the new concern is genuinely independent of all + existing rows + +6. **If no hits**, file the new row. + +### `depends_on` schema extension + +When the pre-filing check surfaces a dependency relationship, +encode it in the new row's frontmatter: + +```yaml +--- +id: B-NNNN +priority: P2 +status: open +title: ... +created: YYYY-MM-DD +last_updated: YYYY-MM-DD +depends_on: # NEW optional field + - B-NNNN-existing-row # blocking dependency + - "Otto-task #N" # TaskList dependency (quote required: # starts a YAML comment unquoted) +--- +``` + +YAML quoting note: values containing `#` (after whitespace) +must be quoted to avoid being parsed as comments — strings +like `Otto-task #323` get silently truncated to `Otto-task` +without quotes. Use double-quotes (`"Otto-task #323"`) for +all `Otto-task #N` and `PR #N` values in `depends_on:`. + +`depends_on` semantics: the depending row CAN be filed +immediately, but its work shouldn't START until the +depended-on row reaches a defined state (typically +`status: closed` or a specific milestone within the row). + +**Tooling state — envisioned, not yet implemented.** As of +this memo's authoring, `tools/backlog/generate-index.sh` +parses only `id` / `status` / `title` from frontmatter +(priority is derived from the directory path +`docs/backlog/P{0,1,2,3}/`), and does NOT consume +`depends_on`. The schema field is the *forward-compatible +authoring shape*; downstream tooling lands as separate work: + +- **Topological-sort view** — candidate generator extension + to emit a DAG-ordered listing of the backlog. +- **Cycle detection** — candidate lint to reject + `depends_on` cycles at PR time (memories and backlog + rows can only point backward in time, like commits). +- **Schema documentation** — `tools/backlog/README.md` + needs a `depends_on` row added when the tooling lands. +- **Start-work guard** — candidate hook to flag attempts + to mark a row `in_progress` when its deps are still + open. + +None of these exist today; they are the *natural mechanization +trajectory* the schema unblocks. Authoring rows with +`depends_on:` populated NOW means the data is in place when +tooling catches up; reading the field is the agent's +discipline until then. + +Example: B-0150 (timeseries domain expert + teacher persona) +should `depends_on: ["Otto-task #323"]` (per-tool/language +expert skills — which is the broader pattern B-0150 +instantiates; quotes required because of the `#`). +B-0153 (pre-commit lint suite) should +`depends_on: [B-0033, B-0086]` (sibling tooling concerns; +B-NNNN values are unquoted-safe). B-0151 (RX researcher) +should `depends_on: [B-0017]` (operational resonance +dashboard with continuous UX research). + +The backlog becomes graph-shaped (a DAG once tooling lands) +rather than flat. Each new row is either a leaf (no deps) +or an internal node (deps known + encoded). The DAG view +and cycle-rejection are tooling targets, not present +implementation. + +### 2026-05-01 audit — failure mode demonstrated + +This very session (2026-05-01), Otto filed 10 backlog rows +(B-0144 through B-0153) WITHOUT running the pre-filing check. +Quick post-hoc audit found: + +- **B-0150** (timeseries domain expert + teacher persona) + + **B-0151** (RX researcher persona) overlap with TaskList + Otto-task #323 (per-tool/language expert skills) and + Otto-task #351 (TS+Bun expert + teaching skill). Filed + without checking the TaskList. +- **B-0153** (pre-commit lint suite) overlaps with B-0033 + (otto discipline hooks system substrate as mechanism + claude-code-plugin) and B-0086 (port tools/hygiene python + to typescript/bun). Both existed; neither was integrated. +- **B-0151** (RX researcher) overlaps with B-0017 + (operational resonance dashboard with continuous UX + research). Both existed; neither was integrated. + +The audit IS the demonstration of the failure mode. + +### Mechanization candidate + +Add as **class 14** in B-0153 (PR #1120) — "pre-filing +similar-row grep check." Two viable mechanization shapes +(the right git hook depends on whether the gate runs +*before commit message authoring* or *during commit message +finalization*): + +- **`pre-commit` hook** on `docs/backlog/B-NNNN-*.md` + file-create — extracts keywords, greps + `docs/backlog/` + `memory/`, reports the hit-list, + fails if any hit found. Author must rerun the commit + with an explicit override flag (e.g., + `git commit --no-verify` or an env var + `OVERLAP_CHECKED=1`) after manual review. Pre-commit + runs before message finalization, so a commit-message + tag is NOT readable here. +- **`commit-msg` hook** alternative — runs after the + commit message is written but before the commit is + finalized; CAN read message content. Would let the + author write `[overlap-checked]` in the message body + to acknowledge the review. + +Either shape works; the first (pre-commit + override +flag) is simpler. Implementation choice deferred to +B-0153's landing. + +The mechanization is straightforward; it's the discipline +that's been missing, and the recurrence is the evidence. + +### 2026-05-01 follow-up — edge schema for memory files + +Aaron 2026-05-01 (right after the backlog `depends_on` +extension above): + +> *"you could have a related to our some other edge in +> memories, up to you, they are very much your domain"* + +Aaron generalized the graph-shape from backlog rows to +memory files. The same overlap problem afflicts `memory/` +— ~367 memory files are unindexed in MEMORY.md (task +#291), and overlapping memories on the same topic +accumulate without being linked. Edges turn the memory +tree into a navigable graph. + +Aaron's *"up to you, they are very much your domain"* is +explicit delegation; the design choices below are Otto's +under the no-directives + autonomy-first-class framing. + +#### Edge types (six classes, all optional, forward-only) + +| Edge | Semantics | +|---|---| +| `extends` | This memory adds to an earlier memory; both stay in force. (Example: the 2026-05-01 extension to this 2026-04-23 file.) | +| `supersedes` | This memory replaces an earlier memory entirely; the earlier becomes historical. (Rare — most evolution is `refines`.) | +| `refines` | This memory sharpens an earlier memory's scope without replacing it. (Example: Otto-364 refines Otto-247; predecessor stays.) | +| `contradicts` | This memory explicitly conflicts with another; reader needs to know both exist. (Glass-Halo: surface contradictions, don't paper over.) | +| `composes_with` | This memory works alongside another; neither subsumes nor depends. (Promotes existing prose `## Composes with` sections to machine-readable form.) | +| `caused_by` | This memory was triggered by a specific event / incident / PR / message. (Free-text, not file-pointer.) | + +Forward-only by design — each file owns its outgoing claims; +reverse navigation is `grep -lrE "supersedes:.*X" memory/` +away (the `-r` recurses into the directory; `-E` enables +the regex `.*`). Bidirectional edges require dual-write +discipline that always drifts; forward-only matches +Glass-Halo file-as-source-of-truth. + +#### Authoring discipline + +Mirror the backlog pre-filing check. When drafting a new +memory file: + +1. **Identify keywords** from the working title. +2. **Grep `memory/`** for related memos (use `-nirE` for + filename:line:context; `-l` alone returns only filenames + without context): + + ```bash + grep -nirE "|" memory/ + ``` + +3. **Read the hits** (or at least their MEMORY.md + descriptions). +4. **Choose the relationship**: extends / supersedes / + refines / contradicts / composes_with / caused_by — or + none, if the new memory is genuinely orthogonal. +5. **Encode in frontmatter** under the chosen edge field(s). + +#### Frontmatter schema + +```yaml +--- +name: ... +description: ... +type: feedback +originSessionId: ... +extends: # optional, list of filenames + - feedback_NAME_DATE.md +supersedes: # optional, list of filenames + - feedback_NAME_DATE.md +refines: # optional, list of filenames + - feedback_NAME_DATE.md +contradicts: # optional, list of filenames + - feedback_NAME_DATE.md +composes_with: # optional, list of filenames + - feedback_NAME_DATE.md +caused_by: # optional, list of free-text strings + - "PR #1234 review thread" + - "Aaron 2026-05-01 messages" +--- +``` + +All edge fields are **optional**. New memories CAN add +them; existing memories get them incrementally as they're +touched. The 376KB of existing MEMORY.md doesn't get +retroactive edges (that's task #291-scale work). + +#### Pointer values + +References within `memory/` use the **filename** +(basename, not full path): + +- `extends: [feedback_version_currency_always_search_first_training_data_is_stale_otto_247_2026_04_24.md]` + +External-surface references (PR / issue / TaskList / +maintainer messages) live under `caused_by:` as +free-text strings. + +#### Mechanization candidate + +Add as **class 15** in B-0153 — "memory-edge +target-existence lint." Sibling-shape to the existing +`.github/workflows/memory-reference-existence-lint.yml` +which currently validates that `memory/MEMORY.md` link +targets exist under `memory/` (its scope is the index, +not all prose links). The new lint would parse memory +file frontmatter, extract edge fields (`extends` / +`supersedes` / `refines` / `contradicts` / `composes_with`), +and validate that the named filenames exist in +`memory/`. Cycle-detection (rejecting `extends` / +`supersedes` cycles at lint time) is a candidate +companion check; not yet implemented. + +#### Why prose `## Composes with` sections stay + +Frontmatter edges are **terse pointer-lists** for machine +traversal (graph audits, visualization, navigation +tooling). Prose sections **narrate the relationship** for +human readers. They serve different purposes; one +doesn't replace the other. Memories with rich relational +context keep both; memories with clear simple +relationships can use just the frontmatter. No +duplication required, no migration needed. + +#### What this is NOT + +- **NOT a retroactive sweep** — task #291 is the right + place for backfilling. The edge-schema is + authoring-discipline-going-forward. +- **NOT a graph database** — git-flat-files-with-grep is + the store; the graph is just an emergent view from + walking edges via `grep -lrE` (the `-r` recurses; `-l` + lists matching filenames). +- **NOT a replacement for MEMORY.md** — the index stays + as the cold-start reading order; edges are per-file + relational claims, not a global index. +- **NOT bidirectional** — forward-only by design; reverse + navigation is `grep -lrE "(extends|supersedes|refines|contradicts|composes_with):.*X" memory/` + away (the field names are the literal frontmatter keys, + not a generic `edge:`). +- **NOT required at PR-time** — adding edges is + encouraged when the relationship is obvious during + authoring; absence of edges is not a lint failure. + +#### Worked example — this very file + +If this `feedback_backlog_hygiene_*.md` were rewritten +today with the new schema, its frontmatter would gain: + +```yaml +caused_by: + - "Aaron 2026-04-23 backlog-hygiene cadenced-refactor message" + - "Aaron 2026-05-01 'i've repeated myself on several designs' message" + - "Aaron 2026-05-01 'depends on if you find that relationship' message" + - "Aaron 2026-05-01 'related to our some other edge in memories' message" +composes_with: + - feedback_class_level_rules_need_orthogonality_check_extend_or_create_aaron_2026_05_01.md + - feedback_signal_in_signal_out_clean_or_better_dsp_discipline.md + - feedback_free_work_amara_and_agent_schedule_paid_work_escalate_to_aaron_2026_04_23.md +``` + +The 2026-05-01 extension to this file IS itself an +`extends` edge in narrative form; if a separate file had +been created instead, the new file's frontmatter would +carry `extends: [feedback_backlog_hygiene_..._2026_04_23.md]`. + ## Composes with - `docs/BACKLOG.md` — the target surface