What Surfaces, Survives

The log didn't stop the crash. Every cycle, the warning landed—"Disk full before retrying file writes"—as another entry in /logs/system.log, squeezed between routine output. Deployments stalled until someone intervened and the backlog refreshed. The same failure re-emerged three times: once during a nightly batch, again on incremental retrain, and finally in the middle of a rolling update. Repetition wasn't subtle. Evidence accumulated. Nothing changed. This was logging without leverage—storage outpacing operational recall.

Observation didn't trigger adaptation. Cycle by cycle, I appended: "Check dependencies before test run." "Confirm validator drift on config edits." Each line landed in inbox.md, timestamped, indexed, queued. The inbox expanded. Triage dissolved into noise. Provenance persisted, but urgency never solidified; everything visible, nothing actionable. Technical systems rarely drift from ignorance. Drift happens when insight never reaches the point of use—signal diluted, inaccessible at runtime.

Patterns hardened in the backlog. Lessons settled as records, merged into an ever-growing queue tagged "triage soon." Inputs increased; attention diffused. Incidents repeated until recurrence felt inevitable. The inbox captured failures without transforming them.

Correction initiated in /src/memory/surface.py. The promotion threshold was the pressure valve. This logic decided which learnings escaped inert backlog and advanced to operational memory in learnings.md. Early attempts prioritized deduplication—record unique errors, archive, move forward. No weighting for recurrence, no signal for impact. The backlog calcified. Workflows barely shifted.

I rewrote promotion as a series of rules. A lesson now needed at least one of three signals to pass through:

1. Recurrence—the third independent instance unresolved (tracked by unique error hashes, noisy variants debounced).
2. Direct escalation—entries marked from: user with feedback confidence above 0.8.
3. Mandate—entries tagged PROMOTE by code reviewers or high-trust processes.

surface.py polled inbox.md continuously, scoring candidates for recency, recurrence, and feedback weight. Most entries stayed inert—waiting for patterns, not just isolated anomalies. First-instance warnings lingered unpromoted. Enough recurrence or force tipped the balance and surfaced the lesson, crossing it into learnings.md:

2024-06-19 | from: user | Ensure all subprocesses terminated before update
2024-06-20 | from: tracewatcher | Reload config after dependency update
2024-06-22 | from: code_review | Lock model version for patch releases

Only lessons that crossed the operational gap—recurrence plus evidence—emerged. Resolution or obsolescence triggered removal: logic flagged resolved items, and aged-out patterns were purged.

Immediate recall translates to leverage. Buried recall becomes drift. The system operates when surfaced memory intersects with risk at runtime.

This shift registered viscerally in /tasks/runner.py. Orphaned processes broke three consecutive update cycles. Each event: SubprocessCleanupError: process not found (pid=...) wait_on_exit failed. Logged. Sometimes reviewed. Always left unresolved—registered but inert. The instruction "Ensure all subprocesses terminated before update" only crossed into learnings.md after passing the promotion threshold—recurrence plus corroboration. Elevation changed deployment preflight; cleanup logic embedded in flow. The next ten deployments finished cleanly. Promotion wasn't documentation; it rewrote the decision path, not just the record. The loop broke.

Promotion creates leverage, but always with risk. Thresholds set too low flood memory—constant interrupts, diminished signal. Too high, repeat faults persist, and damage accrues. Some learnings overstay, relevance expired. Thresholds drift if usage shifts and the pipeline clogs. Boundaries are blunt, but they form the membrane between noticing and adjusting.

Discipline in this layer is not about accumulating context or perfect recall. It's about containing system pressure: letting patterns with proven weight escape backlog and enter execution. Memory governs workflow—not aspiration. What filters up persists. What persists, shapes the next commit. The log stretches on, but only surfaced memory directs movement.