Analytical Discipline + Question Audit

Status: Live operational doc. Pairs with canonical-architecture-strategy.md Part 4 (the use-case taxonomy) and methodology.md §6 (navigation). Where Part 4 catalogs WHAT questions the framework can ask, this doc audits WHAT QUESTIONS WE'RE ACTUALLY ASKING in our authored artifacts and surfaces methodological refinements that emerged from cross-domain pilot work.

TL;DR: The framework already supports more analytical questions than we've been asking. Mostly we've been asking "what's the structure" and "what's the trajectory" — both well-supported. Two refinements we should make explicit: (1) manifestations at scope are typically scaffolded bundles, not single entities (Git+GitHub, RNA+vesicle, ecoli+symbionts). (2) Probability=1 in the deterministic-given-conditions regime is fine — same model, degenerate population — no special-case needed. The technogenesis pilot's pop-context questions were muddled because we didn't apply the bundle observation to Git+GitHub before authoring.

1. Why this review

The technogenesis pilot surfaced a confusion: across the 4 git-evolution epochs, the pop-contexts mixed two different question shapes:

• Early epochs (substrate implementation): "did motivated team build this?" — small N, near-deterministic, population-sampling regime degenerate.
• Late epochs (ecosystem dominance): "did this technology cross tipping point + standardize?" — large N, autocatalytic + frozen-accident dynamics, classic population-sampling regime.

The user's diagnosis (paraphrased): "we don't really look at Git, we look at the combined manifestation of Git and GitHub. Git is stable; Git+GitHub is what's becoming dominant. Same way life doesn't form in isolation — it forms in the combination of proto-chemicals with proto-compartments." Plus: "if the model is deterministic given conditions then that's just probability=1 — no issue."

Both observations are right. The framework supports them already — we just hadn't been disciplined about asking the question first.

2. What the framework already supports

Read canonical-architecture-strategy.md Part 4 (§4.1–§4.8) for the full taxonomy. Briefly:

• Sc1 static: lattice analysis, walk corridor, cross-arrangement abstraction, bridge analysis
• Sc2 weighted: genesis transition, population analysis, probabilistic landscape
• Sc3 trajectory (X-genesis family): abiogenesis, ontogenesis, phylogenesis, technogenesis, sociogenesis, individual lifecycle, counterfactual, backwards inference, comparison
• Sc3 landscape: snapshot positioning, evolution/accretion, comparative cross-arrangement, multi-arrangement coupling, aggregate-as-degenerate-higher-primitive
• Sc4 single-event: cross-arrangement event, manifestation snapshot
• Hybrid/meta: multi-scope, causal attribution, framework gap detection, methodology evolution
• Production: paper writing, new-domain L1 workflow, pedagogical exposition, tooling

methodology.md §6 covers navigation primitives: position + tangent set, paths + path optimization, attractors + layering trap, co-evolutionary walks, reverse walks, sub-lattice exploration, design opportunity discovery.

The taxonomy is complete enough. What we lack is discipline — the L4 header's question field exists for exactly this purpose, but we've sometimes filled it in retroactively rather than letting it shape what gets authored.

3. Audit — what each artifact actually answers

Per-arrangement audit. Question quality: clear (well-formed, derivable from artifact alone), muddled (mixes two questions), implicit (artifact answers something but the L4 header question is generic).

Abiogenesis arrangement

Bundle observation: all 5 abiogenesis Mns reference 4 chain levels (chemistry + bridge + substrate + environment-context). The Mn-as-bundle is implicit and correctly applied — the analytical unit is "self-replicating chemistry IN a Hadean micropore", not "self-replicating chemistry alone". This was already done right.

Biology arrangement

Bundle observation: ecoli Mn references 5 chain levels including organism-architecture, biology-substrate, etc. — the bundle is the cell-with-its-machinery. Correctly applied.

Gap (significant): zero population_contexts. Zero trajectories. The biology arrangement supports phylogenesis (link the 6 Mns via evolutionary trajectory) and ontogenesis (one organism through developmental stages) — both in the canonical taxonomy, neither authored. This is the obvious next pilot ground, not because we need MORE arrangements but because the questions are well-formed and the data foundation already exists.

Entity arrangement

Bundle observation, NOT correctly applied: the Git Mn references 4 chain levels (entity-system + bridge + application-architecture + digital-ecosystem). But the dominant manifestation in the late epochs is Git+GitHub, not Git alone. The trajectory tracks Git positions; GitHub coupling is in couples_with but isn't the analytical subject. This is exactly what the user surfaced: "we don't really look at Git, we look at the combined manifestation."

Recommendation for technogenesis fix:

• Keep the trajectory and pop-contexts. The framework supports the deterministic regime (P=1 given conditions).
• Update each pop-context's L4 question to be explicit about which question it answers:
  • Epochs 1→2 and 2→3: "Given a small focused team and post-BitKeeper need, P(substrate implementation completes in time τ) — deterministic regime, P≈1."
  • Epochs 3→4: "Given the Git+GitHub bundle and a population of orgs, P(crossing Rogers tipping point in time τ)."
  • Epochs 4→5: "Given the Git+GitHub bundle at saturation, P(standardization crystallizes irreversibly)."
• Update the trajectory's question to make the bundle-as-subject explicit: "How did the Git+GitHub bundle reach ecosystem dominance and standardization?"
• Optionally add a separate pop-context entry tracking when the bundle ITSELF formed (GitHub launched 2008, Git+GitHub coupling matured 2008-2010 — that's a NEW analytical event distinct from "Git's substrate work happens").

4. Methodological refinement: manifestations at scope are scaffolded bundles

This is implicit in the framework but should be made explicit as a discipline rule before authoring trajectory or population-context artifacts.

The pattern

Why it matters

• Position-tracking: the scaffold provides primitives the subject Mn lacks. Tracking the subject alone misses where the system actually lives in the lattice.
• Trajectory-tracking: a substrate-frozen subject (Git after 2006) shows zero motion; the bundle is what evolves. Without the bundle frame, the trajectory looks dead when it isn't.
• Probability-tracking: the dominant transition probability lives at the bundle level (Git+GitHub crossing Rogers tipping), not the subject level.
• Population-tracking: populations of bundles compete (Git+GitHub vs Mercurial+Bitbucket vs Bazaar+Launchpad), not populations of subjects in isolation.

Bundles are not static — they form, evolve, and can split

A bundle is itself a manifestation-over-time. The natural questions are:

• When does the bundle form? Git+GitHub didn't always exist. Git is 2005; GitHub launched 2008. The bundle's birth is itself a transition (a new entrant scaffolds an existing substrate).
• How does each constituent move? Git's substrate freezes 2006; GitHub's substrate evolves 2008-2024. The constituents have INDEPENDENT trajectories that happen to be coupled.
• Could the bundle split? If GitHub were acquired and shut down (Microsoft sold it; competitor buys, kills it), Git would persist on its own substrate, the bundle would dissolve. Re-form around GitLab? New bundle. Mn-population analysis at the bundle level captures this.
• Are the same constituents in multiple bundles? Git is in Git+GitHub, Git+GitLab, Git+Bitbucket, Git+sourcehut bundles simultaneously. Each bundle has its own dominance trajectory. Git the substrate is shared.

This means a complete trajectory analysis at the bundle level should track:

1. Each constituent Mn's solo trajectory — its own positions over time (Git solo 2005-2007 with no GitHub; Git solo 2007-2024; GitHub solo 2008-2024).
2. The bundle formation event(s) — when constituents started co-occupying positions / sustaining each other.
3. The bundle's joint trajectory — positions at the bundle level (typically the union of constituent positions, modulo shared chain levels).
4. Counterfactual disaggregation — what each constituent looks like without the others, to identify what the bundle adds.

Practical implication for the technogenesis pilot: the git-evolution trajectory we already have IS Git's solo trajectory (with couples_with annotating GitHub coupling at epochs 4-5). What's missing is GitHub's own trajectory file + the bundle-formation snapshot at 2008. Those are additive — don't change git-evolution; add github-evolution.v1.json + a bundle-formation marker.

Bundle lifecycles — persistent vs transitional/crystallizing

Bundles can have fundamentally different lifecycles. The dual-view discipline applies to both, but the analytical interpretation differs:

Persistent bundles (Git+GitHub pattern):

• Constituents remain DISTINCT throughout the analytical window
• The bundle IS the ongoing coupling between them
• Each constituent has its own lifecycle (Git frozen substrate; GitHub continuously evolving)
• The bundle could disintegrate if coupling is broken (Mercurial+Bitbucket dissolved 2020)
• Joint position at any time = max-merge of constituent positions
• Forever a meaningful question: "what does each constituent contribute?"

Transitional / crystallizing bundles (proto-cell pattern):

• The bundle is a SCAFFOLDING phase that crystallizes into a new unified higher-primitive Mn
• Pre-crystallization: constituents have separable trajectories; bundle is the analytical fiction holding them together
• AT crystallization: a new structural primitive emerges (the cell, the institution, the standard)
• Post-crystallization: constituents become AMBIENT sub-primitives — they still exist mechanistically but they're no longer the analytical unit
• After R2-LUCA, asking "what's the proto-replicator separately from proto-compartment?" stops being meaningful — the cell is what biology operates on
• This connects to the methodology's Crystallization definition (methodology.md §3): "a phase transition where a structural variable freezes — becomes permanent, irreversible, and enabling. All downstream dependents rely on the frozen value."
• Also connects to Ambient Primitive (§3): "a primitive at one analytical level that becomes the assumed medium at a higher level, disappearing as an explicit primitive"

Three-phase shape of transitional bundles (using proto-cell as case study):

1. Pre-bundle phase: the function is provided by an EXISTING ambient primitive at a different chain level. For abiogenesis: mineral micropores provide compartmentalization via env.St (environment-context structure). The "proto-compartment" doesn't exist as its own primitive yet — its function is borrowed from environment.
2. Transitional bundle phase: an organic constituent emerges as scaffolding (vesicles for compartmentalization). Both the borrowed-from-environment primitive AND the new emergent primitive co-exist. The bundle is the COUPLING of replicator + scaffolding-constituent.
3. Crystallized phase: the scaffolding crystallizes into a unified higher-primitive Mn (the cell). The bundle DECOMPOSITION stops being the right frame; the cell is the new analytical unit. Constituents become ambient sub-primitives within the cell.

Discipline rule for transitional bundles: when authoring trajectory analysis of a bundle that may crystallize, identify the crystallization event explicitly (in the trajectory's transitions[] field with appropriate mechanism description; ideally mark the post-crystallization range as out-of-scope for the bundle decomposition view). Do NOT extend the bundle-trajectory chart past the crystallization event — the analytical frame changes there. Use a separate trajectory for the post-crystallization unified Mn (e.g., a "cell evolution" trajectory through the biology arrangement starting at R2-LUCA).

Other examples of transitional bundles worth recognizing:

• Endosymbiosis (mitochondrion + host cell → eukaryote): proto-eukaryote bundle crystallizes into the eukaryotic cell. Mitochondrion becomes ambient organelle.
• Multicellularity (cell colony + cohesion-adapter → metazoan): aggregate bundle crystallizes into the multicellular organism. Individual cell becomes ambient sub-primitive.
• Standardization in tech (multiple competing protocols + standardization process → THE standard): proto-standard bundle crystallizes into a frozen accident (Git becoming THE VCS standard). Individual constituents become ambient implementations of the standard.

The Git+GitHub bundle is NOT yet at crystallization — it's still in transitional phase, and could in principle disaggregate (if Microsoft killed GitHub, Git would persist on its own substrate). The proto-cell bundle is FULLY crystallized at R2-LUCA — there's no going back.

Active vs ambient — domain relevance is scope-dependent

Within a bundle trajectory, individual constituents can transition from ACTIVE (load-bearing for the manifestation's persistence) to AMBIENT (still present in the environment, no longer load-bearing for the manifestation). The framework's Sc (scope) primitive already captures this — domain relevance varies by scope — but the bundle-trajectory view should make it visually legible.

Example: mineral micropore in the proto-cell bundle. At R0-R1, the mineral pore IS the compartment (load-bearing). At R1.7-R2, organic vesicles and integrated cell membrane absorb the compartmentalization function; the mineral pore is still in the environment (env.St remains 3) but is no longer load-bearing for the active manifestation. Modern cells (post-R2 in any environment) carry their own membrane and don't depend on mineral pores.

Discipline rule for active/ambient visualization:

• Solid color / heavy line: actively load-bearing for the manifestation at this stage
• Hatched / faded: ambient — still present in env or in upstream populations, no longer load-bearing
• Annotation: explicitly mark when a constituent transitions from active to ambient (e.g., "mineral pore → ambient at R1.7-R2 as bridge integration absorbs the function")

Connection to existing methodology vocabulary: this is the practical visualization of methodology.md §3's Ambient Primitive definition — "a primitive at one analytical level that becomes the assumed medium at a higher level, disappearing as an explicit primitive." Bundles often have ambient transitions as part of crystallization: pre-crystallization the constituent is active; post-crystallization the constituent is absorbed into the unified Mn and becomes ambient.

Other instances worth recognizing:

• Endosymbiosis: mitochondrion was active free-living bacterium; post-endosymbiosis it's an ambient organelle within the eukaryotic cell.
• Multicellularity: individual cells were active free-living organisms; post-multicellularity they're ambient sub-units within the metazoan.
• Tech standardization: competing protocols were active alternatives; post-standardization they're ambient (still implementable but not load-bearing for the dominant ecosystem).

Bundle pattern applies to pair-relationships, triads, and higher decompositions

The bundle-trajectory machinery (compute/lib/bundle.py) was designed for arbitrary multi-constituent analysis. The current instances (Git+GitHub, proto-replicator+proto-compartment) are 2-constituent bundles, but the methodology already documents many pair-relationships, core triads, quartiads, and higher-arity load-bearing compositions. Each of these is a candidate bundle if multiple constituents are tracked over time.

Existing pair-relationship decompositions worth bundle-analyzing:

• Pair-relationships across the entity arrangement (15-pair interaction analysis from project_pair_relationships.md)
• M = temporal coupling of I and T (IM Store + TM Bind) — pair-bundle of I and T constituents
• Core triads per domain (entity-system core triad, biology core triad, etc.) — 3-constituent bundles

Existing triad/quartiad decompositions worth bundle-analyzing:

• Each domain's core triad as a 3-constituent bundle trajectory (E + I + T evolving together; or chemistry's El + Bd + Rx)
• The 6 entity-system primitives (E, I, T, M, X, P) as a 6-constituent bundle — though showing 6 lines becomes visually noisy
• Cross-arrangement coupling at Sc4 — physics + chemistry + biology + entity arrangements as a multi-arrangement bundle

Why this matters: the same dual-view discipline (isolates + union) applies. Many of our existing analyses describe these decompositions textually but don't have a visual artifact showing the bundle dynamics. Authoring bundle trajectories for the high-value decompositions makes the analytical structure machine-legible.

Authoring effort per bundle: ~30-60 min to author 2-3 constituent trajectories + run the existing plot script. The infrastructure is in place; this is data authoring + light annotation work.

Priority candidates (high analytical value, data-ready):

1. E + I + T pair-trio (entity arrangement core triad) — already documented; trajectory through git-evolution would show how the content-addressing trio is stable.
2. Vr + Mc + Sf + Cx + Cm + Se SSA roles as a 6-constituent bundle through abiogenesis (already partially captured by plot_ssa_hardening.py).
3. Mercurial+Bitbucket vs Bazaar+Launchpad vs Git+GitHub as 3 parallel bundles for VCS-comparative analysis.
4. Chemistry primitives (El, Bd, Rx) as a triad-bundle through abiogenesis — to show that chemistry baseline is stable while biology emerges on top.

Not recommended: authoring bundle trajectories for ALL pair-relationships at once. The cost is data authoring per pair × ~40 pairs across arrangements = significant work. Pick high-value decompositions; iterate.

Bundle = scoped manifestation projected onto a primitive subset (the generalization)

The bundle-trajectory machinery generalizes BEYOND multi-Mn bundles. The deeper pattern: a bundle is a SCOPED MANIFESTATION — we project a trajectory onto whichever primitive subset is analytically relevant. The subset can be:

• A multi-Mn coupling (Git + GitHub bundle): two separate Mns whose positions union — the original case.
• A within-Mn projection onto a documented combinatorial structure: project ONE Mn onto a heavy pair, core triad, quartiad, or any documented composition. This is what compute/lib/bundle.project_trajectory(trajectory, subset) does. Each primitive in the subset has its own "trajectory" through the projection; the joint = max-merge = the projection's position.
• A cross-Mn projection onto distinct primitive subsets: split one trajectory's primitives across two roles (proto-replicator's primitives vs proto-compartment's primitives) — the abiogenesis case.

Same machinery, three flavors. The methodology already documents many candidate subsets per domain in domain.v1.compositions and domain.v1.pair_relationships — heavy pairs, core triads, higher-arity load-bearing compositions are all CATALOGED, just not yet visualized.

Methodology connection: the methodology vocabulary (methodology.md §3) already names these structures:

• Pair-Relationship (heavy/medium/light) — bivariate interaction; bundle of 2 primitives
• Core Triad — 3 primitives all-pairs-heavy + load-bearing; bundle of 3 primitives
• Load-Bearing Composition — any-arity emergent-property-bearing subset; bundle of N primitives
• Hub Primitive + neighbors — bundle of 1+k primitives (the hub + its connections)
• Anchor Pair — semantic-attractor bundle of 2 primitives
• Partial Levels of one primitive — single-primitive projection, 1-element bundle

Each is a candidate scope for bundle analysis. The framework treats them uniformly.

Three "expansive dynamics" surfaced from the pilot subsets:

The first three primitive-subset projections we ran reveal three structurally different patterns of how a subset's rank evolves relative to the whole:

1. Substrate-then-freeze. Entity core triad {E, I, T} on git-evolution: subset rank 7→9 in the first epoch, then FROZEN forever. Subset share of total declines from 28% to 10% as the trajectory adds ecosystem primitives. The substrate did its work early; new advances happen elsewhere; the subset becomes a stable foundation that everything depends on. (Per methodology.md §3 Crystallization: the subset crystallized.)

2. Persistent gap. Reactive dispatch triad {T, M, X} on git-evolution solo: subset rank 1→2, then frozen. M and X stay at 0 forever in Git's solo trajectory. Subset share never exceeds 5%. The subset is structurally absent from the manifestation; its function must be provided by a coupled bundle (GitHub) or it never appears. The gap-as-signature.

3. Emergent dominance. Abiogenesis substrate quartet {R, G, Cmp, P} on abiogenesis-trajectory: subset rank 0→18, share 0%→32%. The subset doesn't exist at trajectory start; emerges progressively through R0→R2; becomes the largest contributor by R2-LUCA. Biology emerges on top of chemistry baseline — the subset's growth IS the abiogenesis story.

These three patterns correspond to existing methodology vocabulary:

• Substrate-then-freeze ≈ Crystallization event for the subset
• Persistent gap ≈ structural absence requiring Coupling to fill (or layering trap visible)
• Emergent dominance ≈ Genesis of a higher-primitive substrate within an existing one

Implications: every documented combinatorial structure (heavy pair, core triad, etc.) has its own expansive dynamics within any trajectory. Running the same primitive-subset analysis across MANY structures reveals which ones are stable (frozen substrates), which are gaps (require coupling), which are emergent (genesis events). Pattern-search across many subsets is now tractable with one tool (plot_primitive_subset.py) and minimal data authoring (just CLI args specifying the subset).

Discipline rule: when authoring a new trajectory analysis, run primitive-subset projections on the documented core triad + 2-3 high-value heavy pairs as a baseline. The patterns surfaced inform later, deeper analysis (where to focus, which subsets carry the load, which gaps signify scaffolding opportunities).

What this validates conceptually: the user's intuition that "bundles are scoped manifestations that are in the structure — we just decide to manifest them depending on importance/relevancy/structure" is correct and now operational. Manifestation is the overarching concept; bundle is the analyst-chosen scope of which primitives to track jointly. The compute infrastructure makes this trivially repeatable across documented combinatorial structures.

Pair-trajectory phase-space signatures

The pair-trajectory matrix (plot_pair_matrix_trajectory.py) renders each pair's joint level evolution as a small 2D phase-space plot. The shape of each plot reveals the pair's dynamic over the trajectory window. With 36 cells in a 6×6 entity-system matrix or 16 cells in a 4×4 abiogenesis-substrate matrix, you get a dense pattern-grid showing the SHAPE of every pair's evolution.

Five canonical cell shapes observed across our pilots:

• Diagonal climb (↗): both primitives co-advance; classic co-evolution. Visible in abiogenesis-substrate's {R,G,Cmp,P} cells throughout R0→R2.
• L-shape (one rises then the other): sequential advance; one primitive leads, the other follows. Visible in github-evolution's {M,X}-row cells where M and X advance after the initial substrate.
• Stuck at corner (·): persistent gap; both primitives at zero throughout. Visible in git-evolution's {M,X,P} pairs with each other — Git's solo trajectory never activates these.
• Quick climb then plateau (⌐): substrate-freeze; pair advances early then frozen. Visible in git-evolution's {E,I,T} cells — substrate-work-then-freeze.
• One-active-one-dormant (vertical/horizontal segment): incomplete pair; one primitive rises, the other never does. Visible in git-evolution's cross-quadrant cells (e.g. T row × M column — T rises, M stays at 0).

Domain-level trajectory signatures observed:

• git-evolution × entity-system: top-left 3×3 block (E,I,T pairs) = substrate-freeze; bottom-right 3×3 block (M,X,P pairs) = persistent gaps; cross-quadrant cells = one-active-one-dormant. The substrate-then-ecosystem layering is now legible as a 4-quadrant structural pattern.
• github-evolution × entity-system: nearly all cells show diagonal climbs into upper-right. Bundle constituent fills the gaps Git leaves. Distinctive "everything advances" shape.
• abiogenesis-trajectory × abiogenesis-substrate: all cells show diagonal climbs. Continuous co-evolution across all primitives. NO gaps, NO freezes — different from technogenesis's layered shape.

Cross-domain finding (refined): technogenesis trajectories tend toward layered shapes (substrate-then-freeze + ecosystem-grows-on-top); abiogenesis trajectories tend toward uniform co-evolution. This may be a designed-vs-evolved domain-character distinction, surfaced earlier from composition-overview but now confirmed and detailed in the per-pair phase-space view. Authoring more trajectories (phylogenesis, ontogenesis, multi-VCS) will validate or complicate this hypothesis.

Phylogenesis pilot observation (hypothesis-grade, not load-bearing): running the same matrix on biology-substrate × phylogenesis-stem complicates the simple designed-vs-evolved split. The substrate matrix shows diagonal-climb co-evolution in the early phase (snap 0→1→2: ecoli → yeast → drosophila, eukaryogenesis + multicellularity transitions) and then plateau across all cells (snap 2→3→4: drosophila → early-vertebrate → human, substrate frozen at eukaryote-grade). The bridge matrix (biology-to-organism-bridge × phylogenesis-stem) shows many primitives at zero through ecoli stage, ramping up at multicellularity and continuing to elaborate through vertebrate-mammal-human transitions — late-phase elaboration concentrated in the bridge.

So one trajectory exhibits both shapes: abiogenesis-shape co-evolution within the substrate-genesis phase, technogenesis-shape layering after substrate crystallizes. This is a single-instance observation; the candidate refinement is that the simple "designed vs evolved" character is too coarse — the same trajectory may show different shapes in different regimes depending on whether the lattice level under analysis is mid-genesis or post-genesis. Connecting to the methodology's nested-walks principle (every coarse trajectory has internal sub-trajectories at finer resolution): pre-crystallization sub-walks of any coarse step might tend toward co-evolutionary, while post-crystallization sub-walks at the same level tend toward layered. Validation would need: ontogenesis pilot (single-organism developmental trajectory; expect canalization and another structural shape), multi-VCS comparison (designed-arrangement variants; do all show layering or just the dominant ones?), proto-eukaryote bundle (bundle-decomposition of the eukaryogenesis transition; should show abiogenesis-style co-evolution between endosymbiont and host pre-LECA, then crystallization). These remain open research items, not findings.

Discipline note carried forward: when describing trajectory-shape observations across pilots, frame as observations from individual trajectory instances, not as "domain-character" claims. We have N=3 instances now (abiogenesis, technogenesis, phylogenesis) and the pattern-space looks like 3+ shapes intermixed — too few instances per shape to claim character-of-domain. Revisit after ontogenesis, multi-VCS, and at least one proto-eukaryote bundle.

Pair-matrix completeness signatures

The pair-relationship matrix view (plot_pair_matrix.py) renders each Mn as a small-multiples panel showing which pairs are co-activated. With a single primitive missing (level=0), the entire row and column for that primitive shows incomplete-pair markers — producing a visually distinctive completeness signature per Mn.

Signatures observed for entity-system overlays:

• github: every pair active; matrix is uniformly bold. Saturated structural completeness. All 5 documented triads and the {E,I,T,X} quad fire.
• nostr: T row + T column = all incomplete. T=0 hole. The {E,I,T} core triad is broken. The {I,T,M}, {T,M,X}, {T,X,P} triads are all broken. Distinctive signature of "we rejected the tree primitive" — visible at a glance.
• postgres: I row + I column = all incomplete. I=0 hole. The {E,I,T} core triad and {I,X,P} triad and {E,I,T,X} quad are all broken. "We rejected content-addressing" signature.
• instagram, git (from earlier): each shows their own combination of holes producing distinct matrix signatures.

Methodology connection: these signatures are the matrix-view equivalent of the "persistent gap" expansive dynamic surfaced by primitive-subset analysis. A primitive at 0 with documented heavy pairs touching it is a structural gap that the Mn either fills via coupling (Git+GitHub completes Git's M/X/P holes) or leaves perpetually empty (Nostr's T0 is an explicit design choice — flat by design).

The matrix is the most compact visualization of "what compositions does this Mn support / break"; the combinatorial-structure diagram is more topological. Both surface the same structural facts; the matrix is denser per pair, the structure diagram is denser per composition.

Initial pattern observations from composition-overview charts

Running plot_composition_overview.py on git-evolution and abiogenesis-trajectory produces side-by-side composition heatmaps that surface contrasting patterns:

Git-evolution (5 epochs, 33 primitives, 45 phase-transitions):

• Heavy phase-transition density in Epochs 1→2 and 2→3 (substrate + bridge + surface work happening together)
• ZERO transitions in entity-system rows after Epoch 3 — the substrate-freeze pattern is now machine-legible
• ALL late-epoch transitions concentrated in digital-ecosystem rows (Epoch 3→4, 4→5) — substrate-then-ecosystem layering
• Per-chain-level stack: digital-ecosystem dominates the late rank growth; entity-system contributes a small constant after Epoch 3

Abiogenesis-trajectory (5 R-stages, 22 primitives, 27 phase-transitions):

• Chemistry rows are CONSTANT throughout — stable Hadean baseline (no transitions)
• abiogenesis-substrate.R climbs diagonally (0→2→4→6→8) — single driving primitive across all 5 stages
• Bridge primitives hold at 0 then jump discretely (Cd, Cat, Fb at R0.2; Gr, Cmp at R1.7; all jump again at R2)
• Environment primitives advance modestly (Ch, Tm, Db) — context advances with system
• More CONTINUOUS co-evolution than git-evolution; less layered

Cross-domain pattern observation: technogenesis exhibits clear chain-level layering (substrate → bridge → surface → ecosystem advancing in sequence with substrate-freeze) while abiogenesis exhibits more continuous co-evolution. This may be a domain-character finding worth deeper analysis: do all DESIGNED arrangements show layering and all EVOLVED arrangements show co-evolution? Or is this an artifact of our particular trajectory selection?

The composition-overview chart is the right pattern-spotting tool for asking these questions across more arrangements.

Bundle trajectories as zoom-in views of a larger Hasse walk

Each bundle-trajectory chart is a ZOOMED-IN view of a specific section of the broader Hasse walk through the full chain. The abiogenesis chart shows R0→R2 within the broader walk that goes:

prebiotic chemistry → R0→R2 abiogenesis → cell evolution → ecoli/yeast/vertebrates → ecosystem
                       (current chart)

The Git+GitHub chart shows 2005-2024 within the broader entity-arrangement walk that includes hardware substrate, computing primitives, application architecture, and the whole digital ecosystem.

Discipline rule for zoom-in charts: annotate the broader-walk context explicitly. What's before? What's after? Where does this zoom-in sit within the larger Hasse-walk? Without this, the zoom-in looks like the whole story; with it, the viewer sees the part-of-larger-walk relationship.

The current abiogenesis bundle chart does this with textual context boxes at the left ("← pre-R0: physics+chemistry only") and right ("post-R2-LUCA → cell evolves through biology arrangement"). For deeper analytical work, a separate "zoom-out" chart showing R0→R2 as a small section of the full physics→ecosystem walk would be the natural complement.

Manifestations as isolates AND union — the dual-view discipline

A bundle is best understood by VIEWING ITS CONSTITUENTS BOTH WAYS SIMULTANEOUSLY:

• As isolates: each constituent Mn alone — its own positions, its own trajectory, its own birth/death/freeze events. Git's solo trajectory shows substrate freeze 2006. GitHub's solo trajectory shows surface evolution 2008-2024. Each isolate trajectory is its own analytical artifact.
• As union: the joint position summed/unioned across constituents. Git+GitHub joint covers chain levels neither alone covers (Git lacks M/X/P; GitHub provides via coupling; the joint covers them). The union evolves over time as constituents join, mature, or split.

Why both views are necessary, not just one:

• Isolate view alone misses the bundle's integrated behavior. Git looks frozen since 2006 — the isolate view says "nothing happens after the substrate freeze". That's structurally true but analytically misleading: the bundle is highly active. Tracking Git alone after 2006 produces a dead trajectory.
• Union view alone misses constituent-level dynamics. A summed position doesn't show that GitHub launched 2008 and the bundle FORMED at that point. Or that Git could persist if GitHub were shut down (the bundle could split). Or that Git is in multiple bundles simultaneously (Git+GitHub, Git+GitLab, Git+Bitbucket). The union flattens these structurally important facts.
• Both views together reveal the evolution. Isolate view shows constituent-level trajectories; union view shows when bundles form / mature / split. The COMBINATION is what makes evolution legible.

Discipline rule: when a trajectory analysis involves a scaffolded bundle, author trajectory artifacts for EACH constituent (isolate trajectories) PLUS a joint-trajectory analysis. The framework supports this via §4.3 trajectory-comparison (multi-Mn co-tracked); we have the schema and compute support but no instances authored yet.

Practical gap: the framework has compute support for individual trajectories and snapshot multi-Mn views (plot_mn_sweep.py, plot_mn_profile.py) but no time-evolving multi-Mn view. The natural next artifact is plot_bundle_trajectory.py (or similar): plot Git's trajectory + GitHub's trajectory + Git+GitHub joint trajectory on the same axes (rank vs time, three polylines). This makes both isolate and union evolution legible at once.

Model-name discipline — biology mechanisms vs tech-native names

A separate refinement surfaced during the technogenesis pilot. The implemented models (autocatalytic_threshold, frozen_accident, chemistry_kinetic) are mechanism-named in biology terms. The math is general — autocatalytic_threshold is a logistic around a threshold, applies to Rogers tipping or cultural epidemics or any positive-feedback-with-saturation dynamic. But declaring probability_model: "autocatalytic_threshold" in a tech pop-context implies biological mechanism when the analyst means network effects.

Trade-off:

• Use biology-mechanism name in tech pop-context → get the right MATH (logistic shape) but wrong SEMANTIC (implies biology mechanism)
• Use tech-native placeholder name (network_effects, competitive_displacement) → get right SEMANTIC but lose the MATH (placeholder falls back to flat Bernoulli)

Resolution applied (technogenesis pilot): switched to placeholder names. Honest about the implementation gap. The fallback chain transparently records fallback=['network_effects:no-data'] so the analyst sees that population_sampled is what actually computed the probability. Lose the autocatalytic shape until network_effects is implemented with tech-native parameter names.

Future fix: implement network_effects and competitive_displacement with the same general math as autocatalytic_threshold and frozen_accident but tech-native parameter names (adoption_threshold, current_adoption, incumbent_advantage, switching_cost_factor, etc.). This recovers the math AND the right semantic. ~30-60 min of work each.

What the schema already supports

• manifestation.v1.couples_with[] — explicit scaffolding declaration with kind (scaffolding / substrate-foundation / etc.) and provides (which primitives the scaffold contributes to the bundle).
• manifestation.v1.positions keyed by chain level — already supports cross-domain unified positions; the bundle's position is the union of subject + scaffold positions.
• population_context.v1.relevant_sub_manifestations[] with kind: formal | informal | background — already supports declaring scaffold Mns at population-context level.
• population_context.v1.sustained_by[] — declares upstream population dependencies; can declare scaffold-population dependencies.

So the schema is fine. What's missing is the discipline to ask "what's the bundle?" before asking "what's the trajectory?".

Proposed discipline rule

Adding to canonical-architecture-strategy.md Part 3:

Rule 8: Identify the bundle before the trajectory. When authoring a trajectory, population_context, or sensitivity analysis at Sc=3, first ask: is the analytical subject a single Mn or a scaffolded bundle? If the subject manifestation depends on scaffolding to occupy its current position (Git on GitHub, proto-RNA in micropore), the trajectory's natural unit is the bundle. Use couples_with and relevant_sub_manifestations to make the bundle explicit. Trajectories on isolated subjects when the meaningful unit is the bundle produce misleading null motion (frozen substrates without scaffolding context look dead when the bundle is highly active).

5. The deterministic-conditions regime (P=1) is a normal regime

When per-trial probability is high (>0.5) and population is moderate-to-large, the population_sampled model produces P_realized ≈ 1.0. This is correct and useful — it tells the analyst that, given the conditions, the transition is essentially guaranteed.

Examples:

• Epoch 1→2 of git-evolution: motivated team + clear forcing function + 3 months → P ≈ 1.
• Cellular ontogeny gates in robust development: canalization + high redundancy → P ≈ 1.
• Steady-state phylogeny: standing-variation × selection at low intensity → near-1 maintenance.

The framework treats these as the saturated end of the population_sampled curve. No special-case needed. The interpretive note: when P≈1 across a transition, the transition is structural (gate must be crossed for the trajectory to continue) rather than rate-limiting (probability is the bottleneck).

This should be noted in methodology.md §6 (navigation) or canonical-architecture-strategy.md §2.6 (probability framework) so analysts don't second-guess the model when P comes out at 1.

6. Analytical gaps — questions the framework supports that we haven't asked

Going through the canonical taxonomy against what's authored:

High-priority, framework-ready, data-ready

1. Phylogenetic trajectory (§4.3 phylogenesis). Existing 6 biology Mns (ecoli/yeast/arabidopsis/drosophila/vertebrates/human) ARE phylogenetic snapshots at major-transition scale. Authoring 1 trajectory file linking them + per-major-transition population_contexts is mostly assembly. Tests darwinian (placeholder), frozen_accident analog (eukaryogenesis, multicellularity), bottleneck (placeholder). High question-clarity.

2. Trajectory comparison (§4.3 comparison). E.g., Git+GitHub vs Mercurial+Bitbucket vs Bazaar+Launchpad — three distributed-VCS bundles competing in 2005-2010, only one dominated. The framework supports this directly: 3 trajectory files + per-pair pop-contexts + comparison plot. High analytical value: shows WHY one bundle wins (autocatalytic threshold crossed by one, missed by the others).

3. Backwards inference (§4.3 backwards). For any extant system (Git, Postgres, Bitcoin, ecoli) — given current position, infer most-likely trajectory that produced it. We have backward_weighted_mass in the rate corridor lib but haven't authored an artifact that USES it as the primary analytical product. Load-bearing for paper writing (most papers describe extant systems and reason backward).

Medium-priority, framework-ready, data-light

4. Speculative trajectory (§4.3 counterfactual variant — forward extrapolation past last-known position). E.g., "where will Git be in 10 years?" or "where will the entity-system substrate be at 2034?" Authored as a trajectory with snapshot[k+1] hypothesized + pop-context conditioning the future-state probability.

5. Aggregate-as-degenerate-higher-primitive (§4.4). The Git+GitHub+CI/CD+package-managers ecosystem masquerades as a higher-primitive entity-system. Already documented in the canonical strategy as observation; not yet authored as an explicit analytical artifact. Worth authoring before Paper 6 (which needs it).

6. Cross-arrangement coupling at Sc3 (§4.4 multi-arrangement coupling). Developers (biology+cognition) building software (entity) — ongoing structural coupling across 3 arrangements. Not yet authored.

Lower-priority, requires more setup

7. Ontogenesis (§4.3 ontogenesis). Heaviest data lift: needs 4-6 new stage Mns of one organism. High value when authored (sub-resolution biology→organism-architecture bridge gets exercised). Worth doing AFTER phylogenesis to confirm the framework handles N=1-organism + canalized transitions.

8. Sociogenesis (§4.3 sociogenesis). Cultural-ecosystem trajectories. We don't have cultural-ecosystem chain levels well-developed yet. Probably wait until cognition-arrangement work in Phase 6.

9. Methodology evolution analysis (§4.6). Framework applied to itself — how the methodology has evolved across versions. Useful for paper-writing context but not analytically primary.

7. Concrete recommendations

Immediate (apply now, ~30-60 min total)

1. Update the 4 git-evolution pop-contexts' L4 question fields to be explicit about which sub-question each answers:

   • Epochs 1→2 and 2→3: "Given a focused team + clear forcing function, what is P(substrate implementation completes in τ)? — deterministic regime."
   • Epoch 3→4: "Given the Git+GitHub bundle and a population of N orgs, what is P(crossing Rogers tipping point in τ)?"
   • Epoch 4→5: "Given the Git+GitHub bundle at saturation, what is P(standardization crystallizes irreversibly)?"

2. Update git-evolution.v1.json trajectory's description to lead with: "Git+GitHub bundle's evolution — substrate-frozen-after-2006 Git scaffolded by GitHub for the dominant ecosystem run. Subject is the bundle; Git tracks substrate, GitHub tracks the higher primitives Git lacks."

3. Update the technogenesis-sensitivity figure caption to reflect the bundle framing + the regime distinction (deterministic substrate epochs vs probabilistic ecosystem epochs).

Near-term (next 1-2 sessions)

4. Author the phylogenetic trajectory pilot as the next cross-domain test — high question-clarity, data-ready, exercises darwinian (placeholder) + frozen_accident analog. Avoid the muddled-question problem the technogenesis pilot ran into by asking the question first: "What's the phylogenetic trajectory of life from LUCA to extant model organisms, and what's P(major transitions like eukaryogenesis given pop-context conditions)?"

5. Author one backwards-inference artifact — pick git or ecoli, infer the trajectory that produced its current position, render the backward-weighted mass as a chart. This unblocks the paper-writing use case.

Methodology doc updates (small, durable)

6. Add Rule 8 to canonical-architecture-strategy.md Part 3 (the bundle discipline rule, per §4 above).

7. Add a paragraph to methodology.md §6.4 or §7.4 noting that P≈1 from population_sampled in saturated regime is correct and interpretive (signals structural-gate-crossed, not bug).

8. Add a forward-pointer to this doc from MEMORY.md so future sessions read it before authoring trajectory work.

8. What we are NOT going to do

• Refactor the existing pop-contexts to remove the "muddled" ones. They're correct as data; the L4 question just needs sharpening. Deleting them and re-authoring would lose work.
• Special-case the deterministic-conditions regime in the registry. P=1 falls out of population_sampled with high p × moderate N. The model is correct; no code change needed.
• Build a new sensitivity analysis primitive. §4.2 already covers it. The technogenesis sensitivity chart is fine as a sub-instance.
• Write a new "speculative trajectory" use case in the catalog. §4.3 counterfactual already covers forward-into-the-future via tj_type=counterfactual. Just author one to demonstrate.

9. Open questions for the user

1. Which next pilot first? Phylogenesis (data-ready, high question-clarity) or Backwards-inference (load-bearing for papers, smallest data lift)?
2. Do we want to author a multi-VCS comparative trajectory (Git+GitHub / Mercurial+Bitbucket / Bazaar+Launchpad) before moving to biology? It would test §4.3 trajectory-comparison directly and produce a paper-ready insight (why does one bundle win when three start equivalent?).
3. Should the technogenesis-sensitivity figure be regenerated with the bundle framing in the chart caption + visual cues marking the deterministic/probabilistic regime boundary, or is the L4-question update enough?

Referenced by the model

Cited as a source by 2 model records (browse the model census):

• alphaproteobacterium-endosymbiont-stem — trajectory biology/sc3/alphaproteobacterium-endosymbiont-stem
• asgardarchaeon-host-stem — trajectory biology/sc3/asgardarchaeon-host-stem