Refined sequencing — from where we actually are to AGI-candidacy (2026-06-06)

Status: PLAN (refines AGI-candidacy-autonomous-improvement-roadmap-2026-06-05, grounded in a 7-layer ground-truth audit of the real tree at main + #596). Telos: project-core-is-one-continuous-life — listen → comprehend → recall → think → articulate → learn → replay, as one continuous, ever-improving life, deployable at the edge (offline, CPU-only, deterministic, never fabricating).

The finding that reorders everything

The 2026-06-05 roadmap (MEASURE → COMPREHEND → REALIZE → DETERMINE → LOOP) assumed the work was building each organ. The audit shows otherwise: the organs are built; they are disconnected libraries. Each is correct in isolation and callable only from its own tests.

Layer	Built?	The real gap (verified)
MEASURE	✅ real composed capability index — `evals/capability_index/`, frozen baseline `0.937258`, breadth 8, `wrong_total=0`, deterministic digest reproduces live	#596's relational reader is inert — no adapter; the curve won't register the capability we just shipped
COMPREHEND	⚠️ template matcher, not a general reader — coverage is the template list; only 51/794 index cases exercise general comprehension	not language-general; #596 reader inert (no lane)
REALIZE	✅ write/recall/persist correct (R0/R1/R1c, OOV, Shape B+)	not wired into the live turn loop — "a library, not a lived organ"; no conversation accrues knowledge
DETERMINE	✅ sound one-hop, same-predicate, positive-only, as-told over 17 predicates	callable only from tests; no transitive hop (though `proof_chain` ROBDD exists to reuse); not wired
LOOP	⚠️ `idle_tick` runs, but only advances intentionally-partial discovery chains	does not learn from lived determined facts; `determine` not wired in
ESTIMATION	✅ calibration machinery (`reliability_gate`, Wilson floors) built	no likelihood→serving path — correctly gated off until DETERMINE+MEASURE solid
EDGE-RUNTIME	⚠️ runs CPU-only/offline/deterministic today (verified)	offline-readiness asserted, not proven; per-turn persistence O(n²) cliff bites when `persist_session_state=True`; no budget gate

So the remaining critical path is integration + measurement, not open-ended organ-building. The one genuinely open-ended risk (a general COMPREHEND reader) we grow incrementally on the yardstick, so generalization is proven, not claimed. #596's wrong=0 hazard — fabricating sibling_of(carol, dan_during_school) — is the proof of why: a capability off the yardstick hides its own breaches. (Found by post-merge lookback, fixed in #597.)

Refined critical path

INSTRUMENT ──► WIRE ──► DEEPEN ──► CLOSE ──► [later] ESTIMATION
(put it on    (organs    (transitive  (loop learns
 the yardstick  into one   determine    from determined
 + edge gate)   live loop)  via proof_chain) facts)

Step A — INSTRUMENT (two cheap, independent instruments; parallel-safe)

A1 · Put #596 on the yardstick. Add a comprehension_relational_predicate capability lane: binary-relation prose → gold (predicate, subject, object) triples authored by a source independent of generate/meaning_graph/relational.py (a small relation-table oracle over the closed predicate vocab), scored through comprehend_relational → determine. Append the adapter, re-freeze baseline.json, watch breadth 8→9 and the digest change deliberately.

Falsification: independent gold (INV-25); reader must not share code with the gold producer (INV-27 disjointness). A genuine climb = breadth 8→9 with wrong_total still 0.
Edge: +negligible (<tens of cases; index runs ~0.55s CPU-only).
Why first: it's the only thing that makes "we added a capability" falsifiable — and it would have caught the #596 fabrication as wrong>0.

A2 · Edge budget gate (mission-critical, uncharted by the old roadmap). Add evals/edge_budget/: a fixed-length real chat session with persist_session_state=True, Python backend, that fails on breach of pinned ceilings — per-turn p95 latency, per-turn checkpoint bytes-written, total session bytes. This converts "edge-deployable" from asserted to proven, and instruments the O(n²) persistence cliff before it blocks a clinic/disaster-center deployment.

Falsification: a constrained-device budget the session must stay under across N turns; fails loudly when persistence cost grows superlinearly.
Why now: the mission (disaster center, rural clinic, village school) is the edge axis; it must be a gate, not a hope.

Step B — WIRE: realize + determine into the live turn loop (highest-leverage capability move)

After a declarative (query-free) user turn is comprehended, call realize_comprehension(comprehension, ctx) on the same SessionContext the runtime already holds; answer a later question turn via determine(...) over recall_realized. This is the first time a conversation actually accrues knowledge — the library becomes a lived organ. Directly serves the "one continuous life" telos.

Falsification: a multi-turn replay where turn N+1 answers from turn N's told fact, wrong=0, and the fact survives reboot (Shape B+).
Edge: realize write is O(1) + an O(n) linear vault scan (no ANN); fine on a constrained box — but this is what makes A2's persistence gate load-bearing.
Depends on: A1 (so the gain is measured), COMPREHEND coverage (grow incrementally).

Step C — DEEPEN: transitive determination via the existing prover

When member(a,c) isn't directly grounded, collect realized member facts reachable from a via recall_realized, hand them as opaque Boolean atoms to the existing sound+complete proof_chain ROBDD entailment decider — reuse, don't build new inference. First multi-hop reasoning over realized knowledge.

Falsification: an independent transitive-closure oracle; wrong=0 preserved; every committed conclusion independently checkable.
Depends on: B (facts must be live in the loop first).

Step D — CLOSE: the loop learns from determined facts

In contemplate/idle_tick, promote a grounded sub-question (concrete (connective, object) + determined polarity) into a complete candidate, so the flywheel proposes from what it determined, not just the intentionally-partial discovery chains it emits today. This is the step that makes "forever improving" real and falsifiable.

Falsification: a frozen replay shows the capability index (Step A) climbing across loop iterations, autonomously, under HITL ratification — monotonic, junk-free.
Depends on: B + C.

Step E — ESTIMATION (deliberately last, unchanged from the roadmap)

Only after the assert/refuse floor (B–D) and calibration measurement (A) are solid: wire one LicenseDecision from a committed ClassTally to gate one served answer on the safest action. Never a designed-in default; HITL-ratified.

Invariants (unchanged, non-negotiable at every step)

wrong=0 structural · reviewed learning stays HITL · deterministic replay · identity continuity (L11) · versor_condition < 1e-6 · no forbidden-site normalization · exact CGA recall · every step on the yardstick before it counts · every step under the edge budget.

What changed vs the 2026-06-05 roadmap

The bottleneck is integration, not construction — the organs exist, disconnected. Sequencing is now wire + measure, not build.
EDGE-RUNTIME is promoted to a first-class, gated axis (A2). The old roadmap had no edge gate; the mission requires one.
DETERMINE deepening reuses proof_chain rather than building inference (Step C).
The single highest-risk item remains a general COMPREHEND reader; we de-risk it by growing it on the yardstick, incrementally, so generalization is proven.

8 KiB Raw Blame History Unescape Escape