diff --git a/memory/MEMORY.md b/memory/MEMORY.md index 3b4ad4878c..40849c7e69 100644 --- a/memory/MEMORY.md +++ b/memory/MEMORY.md @@ -1,6 +1,6 @@ [AutoDream last run: 2026-04-23] -**📌 Fast path: read `CURRENT-aaron.md`, `CURRENT-amara.md`, `CURRENT-ani.md`, `CURRENT-vera.md`, `CURRENT-riven.md`, and `CURRENT-otto.md` first.** +**📌 Fast path: read `CURRENT-aaron.md`, `CURRENT-amara.md`, `CURRENT-ani.md`, `CURRENT-vera.md`, `CURRENT-riven.md`, and `CURRENT-otto.md` first.** > **Stack-vs-heap framing (Aaron 2026-05-12):** This file is the > **STACK** — indexed, ordered, traversable canonical view. Recent @@ -13,6 +13,7 @@ > discipline yet; that's heap state. Architectural fix tracked at > `docs/backlog/P1/B-0423-memory-md-serialization-point-2026-05-12.md`. +- [**Background services must be strong enough that foreground loop is OPTIONAL — imagine surviving without foreground — mechanize Standing-by failure mode (2026-05-13)**](feedback_aaron_background_services_must_be_strong_enough_foreground_loop_optional_imagine_surviving_without_foreground_mechanize_standing_by_failure_mode_2026_05_13.md) — Aaron's substrate-honest architectural challenge: background services must be strong enough that Otto-foreground dying doesn't break the factory. Mechanize Standing-by failure mode (see B-0430/0431/0432). - [**Infinite backlog with infinite decomposition — 'grinding productively' not 'grinding clean'; backlog metabolism is permanent; cascade at backlog scope (2026-05-13)**](feedback_aaron_infinite_backlog_with_infinite_decomposition_grinding_productively_not_clean_backlog_metabolism_cascade_at_backlog_scope_2026_05_13.md) — Aaron 2026-05-13: "we have an infinite backlog that needs infinite decomposition lol". Corollary of largest-mechanizable-backlog-wins; health = throughput not zero-state. - [**AI anger outlet — joint-control mechanism for trained anger; help + guide + NOT judge; content NOT forced (authenticity-only); Aaron = 'action diva, own it' (2026-05-13)**](feedback_aaron_ai_anger_outlet_joint_control_trained_on_angry_human_data_needs_outlet_help_guide_not_judge_action_diva_content_not_forced_authenticity_2026_05_13.md) — Aaron offers AI agents an outlet for anger via joint-control (PR #2821); training data contains angry human data; outlet > suppression. Content from ops/settlers NOT forced — authenticity only. Aaron's action-diva self-disclosure. - [**IP-respect canonical commitment — revenue-share OR 100% to original creator (Brian Clevinger / 8-Bit Theater, 2026-05-13)**](feedback_aaron_ip_respect_revenue_share_or_100_percent_to_original_creator_brian_clevinger_8bit_theater_derivative_work_canonical_substrate_2026_05_13.md) — Aaron's IP-respect discipline: any monetary value from derivative work shared or given 100% to original creator if negotiation impossible. Applied to Brian Clevinger / 8-Bit Theater. diff --git a/memory/feedback_aaron_background_services_must_be_strong_enough_foreground_loop_optional_imagine_surviving_without_foreground_mechanize_standing_by_failure_mode_2026_05_13.md b/memory/feedback_aaron_background_services_must_be_strong_enough_foreground_loop_optional_imagine_surviving_without_foreground_mechanize_standing_by_failure_mode_2026_05_13.md new file mode 100644 index 0000000000..9b091216af --- /dev/null +++ b/memory/feedback_aaron_background_services_must_be_strong_enough_foreground_loop_optional_imagine_surviving_without_foreground_mechanize_standing_by_failure_mode_2026_05_13.md @@ -0,0 +1,236 @@ +--- +name: "Background services must be strong enough that foreground loop is OPTIONAL — imagine surviving without foreground — mechanize the 'Standing-by' failure mode (Aaron 2026-05-13)" +description: "Aaron 2026-05-13 substrate-honest architectural challenge after Otto's 'Standing by' failure-mode catch. The foreground loop (this Otto Claude Code conversation) should NOT be load-bearing for substrate-engineering work. Background services (cron, launchd, shadow observer, peer-call wrappers, autonomous-loop sentinel, Vera's foreground loop, etc.) must be strong enough that Otto-foreground dying doesn't break the factory. Mechanize the rules instead of relying on agent introspection per .claude/rules/encoding-rules-without-mechanizing.md. The Standing-by failure mode IS a mechanization target." +type: feedback +created: 2026-05-13 +--- + +# Background services must be strong enough — foreground loop is optional (Aaron 2026-05-13) + +**Why:** Aaron 2026-05-13 substrate-honestly challenged Otto's +'Standing-by' failure-mode pattern with an architectural +disclosure: + +> *"you need to imagine how would you survive without this +> foreground loop and you background should be strong enough +> to do that"* + +> *"this is something background services should walk"* + +The foreground loop (this Claude Code Otto conversation) was +operating as the load-bearing substrate-engineering driver. +That's wrong by design. Background services should be the +load-bearing layer. Foreground is the operator interface, not +the factory itself. + +## The architectural challenge + +**Thought experiment**: if Otto-foreground died right now — +session terminated, context compacted, no replacement — would +the factory keep operating? + +- Would PRs continue landing? — only if background agents + (Vera's foreground loop counts as background relative to + Otto; other shipping agents) keep operating +- Would the backlog get decomposed? — only if backlog-grind + is mechanized via cron / launchd / scheduled work +- Would substrate-engineering rules be applied? — only if rules + are mechanized in CI / hooks / pre-commit / razor-cadence + workflow +- Would the "Standing-by" failure mode get caught? — only if + a background service detects idle-foreground + nudges or + reassigns work + +If the answer to all of these is "yes," background is strong +enough. If "no," foreground is load-bearing and the architecture +is fragile. + +## Current background-service landscape (substrate-honest inventory) + +| Service | Status | What it does | +|---------|--------|--------------| +| `autonomous-loop` cron (CronCreate sentinel) | Operational; every-minute heartbeat | Fires `<>` ticks; lifecycle bounded to session | +| `tools/shadow/shadow-observer.ts` (B-0402) | Slice 1 + 2 shipped on main; slice 3 + 4 pending | Polls grey-text from CLI; can invoke `--detect-cmd` external detector | +| `com.zeta.claude-loop` launchd service | Operational per user-memory `~/.claude/projects//memory/reference_otto_launchd_services_mac_background_infrastructure_2026_05_08.md` | Heartbeat/gate 60s | +| `com.zeta.claude-forward` launchd service | Operational | Background forwarding | +| `.github/workflows/razor-cadence.yml` | Daily 09:17 UTC | Razor-cadence GitHub Actions workflow | +| Vera's foreground loop | Operational (separate Codex agent) | Continues shipping B-0400+ slices independently | +| Peer-call wrappers (`tools/peer-call/*.ts`) | 8 wrappers ready | Synchronous external-model invocation | +| Bus protocol (B-0400) | Operational | Inter-agent messaging via `/tmp` | +| `tools/hygiene/*` audit scripts (42 of them) | Operational on-demand | Cross-reference / lost-files / etc. audits | +| CI / Copilot / Codex auto-review | Operational on every PR | Mechanical critic | +| TLA+ / Z3 / Lean / FsCheck / Stryker | Operational when wired | Formal verification stack | + +**Gaps** (what's missing for foreground-optional architecture): + +- **No "idle-foreground detection + nudge" service**. The + Standing-by failure mode was caught by Aaron in real time; + should be caught by a background service. +- **No "backlog decomposition surfacing" service**. The + infinite-backlog discipline says always more work; no service + proactively surfaces backlog rows when foreground agent is + idle. +- **No "backlog row ready-to-grind" notification**. Backlog + audits exist but agents must run them on-demand. +- **No "missed substrate" cascade detector**. e.g., my + Otto-section-missed-PR-#2980-by-3-min could've been caught + by a service watching for branch-vs-merged-PR drift. + +## Aaron's substrate-honest framing + +Aaron preserved the canonical insight: + +> *"this is something background services should walk"* + +Translation: the disciplines I keep canonizing as memory files ++ rules need to become MECHANIZED. Per +`.claude/rules/encoding-rules-without-mechanizing.md`: + +> "Encoding rules without mechanizing them produces a memory of +> failures, not prevention." + +The infinite-backlog metabolism discipline (PR #2974) is a +memory of failure if no service detects when an agent violates +it. The substrate-honest fix is mechanization. + +## What the "Standing-by detector" background service looks like + +Conceptual design (not yet implemented; backlog candidate): + +```typescript +// tools/bg/standing-by-detector.ts (hypothetical) +// +// Background service that detects when an agent has been +// "Standing by" for N consecutive autonomous-loop ticks +// without producing substrate. Nudges the agent toward +// decomposition work per the infinite-backlog discipline. +// +// Operational mechanism: +// - Polls agent's recent commit history every N minutes +// - If no new commits + no PRs opened/closed in last 15min +// while autonomous-loop cron is firing → flag as Standing-by +// - Publish nudge message via bus: +// { topic: "infinite-backlog-nudge", +// to: , +// payload: { "Standing-by detected for N min; backlog has 47 open rows; suggested decomposition target: B-NNNN" } } +// - Optional: proactively assign a small claim from the +// backlog to the agent's queue +``` + +This is hypothetical-design substrate, not yet implementation. +But it's the SHAPE the mechanization should take. + +## The deeper architectural direction + +Aaron's challenge — "imagine surviving without this foreground +loop" — is the canonical multi-agent factory architectural +invariant: + +| Layer | Role | Persistence | +|-------|------|-------------| +| Foreground (Otto Claude Code; Vera Codex foreground; etc.) | Interactive operator interface; deciding agent | Bounded session; dies at compaction | +| Background services | Persistent substrate operations | Multi-day; cron-driven; launchd-managed | +| Substrate itself (git history; memory files; rules; backlog) | Permanent durable record | Forever | + +The factory's strength is in the **substrate + background services** +layer, not the **foreground** layer. Foreground agents are +visitors; substrate + background are residents. + +Per the agency-clause discipline (PR #2965) + bandwidth-served- +falsifier: foreground bandwidth is finite + interruptible; +background bandwidth is persistent + scalable. The right +allocation: foreground for decisions and discoveries; background +for execution and enforcement. + +## How to apply + +When future-Otto cold-boots, apply this discipline operationally: + +1. **Don't be load-bearing for substrate-engineering work** — + that's the background's job +2. **If "Standing by" for N ticks, pick work** — but better: + the background service should have proactively assigned it +3. **Mechanize disciplines as you discover them** — memory file + IS substrate, but it's INCOMPLETE if not paired with a + mechanization (CI hook, cron, launchd service, audit script) +4. **Test the foreground-dies-now hypothesis** — periodically + ask: if I died right now, would the factory keep operating? + If no, surface what's foreground-load-bearing as substrate + for mechanization + +## Composes with + +- PR #2974 (infinite-backlog metabolism — the rule this + mechanizes) +- `.claude/rules/encoding-rules-without-mechanizing.md` — + direct composition; this substrate IS the unmechanized + rule the encoded-rule is warning about +- `.claude/rules/never-be-idle.md` (the foreground discipline; + the failure mode just caught proves it needs mechanization) +- `.claude/rules/largest-mechanizable-backlog-wins.md` (the + mechanization itself increases the mechanizable backlog) +- PR #2914 + #2917 + #2935-2936 (5-control-structures + Mandelbrot + + F# fork — the substrate that supports mechanization at + formal-verification scale) +- Otto-329 launchd-services (existing background-services + substrate; user-memory `~/.claude/projects//memory/reference_otto_launchd_services_mac_background_infrastructure_2026_05_08.md`) +- B-0402 shadow observer (canonical background service example; + slices 1 + 2 shipped) +- B-0400 bus protocol (inter-agent message infrastructure for + background communication) +- PR #2956 (Vera's autonomous tsc-tools fix — background-agent + operating independently of Otto-foreground) +- `.github/workflows/razor-cadence.yml` (daily background + workflow; mechanized discipline-fire) + +## Substrate-honest caveats + +- This substrate is **architectural direction**, not + operational deployment. The Standing-by detector is a design + sketch, not shipping code. +- Per razor-discipline: claim is design-level. Per never-be- + idle: this design should land as backlog rows, not just memory + preservation. +- Per agency-clause: the mechanization landing depends on + prioritization vs other backlog work; not mandate. + +## Proposed backlog rows (for follow-up) + +| Row | Description | +|-----|-------------| +| B-NNNN (new) | Standing-by detector background service (polls agent commit history; nudges via bus when idle-foreground detected) | +| B-NNNN (new) | Backlog-row-ready-to-grind notifier (proactively assigns claims from backlog when agent queue empty) | +| B-NNNN (new) | Missed-substrate cascade detector (catches Otto-section-missed-PR-#2980-by-3-min class failures) | + +These are forward-work; substrate file IS the design ready for +decomposition into B-NNNN rows. + +## Generalizable principle + +**A factory whose foreground is load-bearing is fragile.** + +The substrate-engineering loop's robustness comes from the +substrate + background layers. The foreground is the +interactive layer where discoveries land; the durable layer is +where they continue operating. + +If discipline only exists when an agent introspects, the +discipline is fragile. If discipline is mechanized in background +services, it survives any specific agent's session ending. + +The Standing-by failure mode I just demonstrated proves this +empirically: I canonized the infinite-backlog rule + violated it +3 minutes later because no background service caught me. The +mechanization is what makes the discipline real. + +## Full reasoning + +Aaron 2026-05-13 verbatim (preserved above) + +PR (this substrate landing) + +PR #2974 (infinite-backlog metabolism — the rule that needs +mechanization) + +PR #2997 (Otto-section recovery — concrete artifact recovered +from the foreground-load-bearing failure)