Information Lifecycle System — Main Street Independent

The part of Ora that organizes how information moves, distinct from the systems that manage the intent and coordination around it.

Overview

The Information Lifecycle System is the part of Ora that organizes how information moves. Where the Strategic Supervision System and the Coordination Layer manage the intent and the enforcement of work, this system manages the substance — the processes that transform information, the corpora that accumulate it between processes, the outputs that render it for consumption, the terrain mapping that precedes definable problems, and the decision clarity work that handles wicked problems where false resolutions would mislead. The system is what the work itself runs through.

Six frameworks compose the system, organized around three roles. The process role has two frameworks: Process Inference (PIF) discovers whether a viable process exists for moving from input to a testable endpoint when the process itself is unknown — it produces P-Feasibility verdicts (Reachable / Reachable with apparatus to build / Unreachable under current constraints / Cannot determine without exploration). Process Formalization (PFF v2.0) formalizes a known process into a bespoke framework that runs reliably across executions — it is a meta-framework, producing other frameworks. The corpus role has one framework: Corpus Formalization (CFF v1.1) formalizes corpora — bodies of information that accumulate between processes — into templates and instances with section-level rules and consumption-declaration semantics; matrices declare consumption of corpora rather than owning them; primary-curator markers resolve multi-consumer cases. The output role has one framework: Output Formalization (OFF v1.1) formalizes outputs — rendered artifacts that express information from corpora and matrices for external or internal consumption — into specifications with cadence rules, source declarations, and consumer-facing format requirements. The frontier role has two frameworks: Terrain Mapping (TMF) handles the case where the problem is not yet definable enough to formalize anything — it produces a Terrain Map Artifact that lets MOM and the rest of the system proceed once the territory is known well enough to define a problem within it. Decision Clarity Analysis (DCA) handles wicked problems where producing a false resolution would mislead — it produces a Decision Clarity Document that names what’s known, what’s contested, what’s irreducible, and what the next-best action is given irreducible uncertainty.

The system covers the input-corpus-output unit at any scale. At the smallest scale, a single process produces a single output from a single input — PFF formalizes the process; OFF formalizes the output; no corpus needed. At medium scale, multiple processes produce multiple outputs from a shared corpus — CFF formalizes the corpus; multiple PFF-formalized processes consume from it; multiple OFF-formalized outputs render from it. At the largest scale, multiple corpora chain through multiple processes producing multiple outputs across multiple matrices — the chain-coordination apparatus (the Coordination Layer) supervises the seams; CFF and OFF specify the corpora and outputs; PFF and PIF design the processes; TMF and DCA handle the cases where the problem itself is not yet workable.

The system is Operation-coordination aware as of 2026-05-08. CFF v1.1 and OFF v1.1 added Operation-coordination semantics — corpora and outputs declare relationships with Operations (an Operation declares consumption of a corpus; an Operation declares which outputs it produces; primary-curator markers on corpora resolve multi-Operation cases; cadence-of-production on outputs may differ from the Operation’s overall cadence). The frameworks themselves are independent CFF and OFF entities; the Operation-coordination layer is a thin annotation that lets the Matrix Lifecycle System’s Operation classification compose with the Information Lifecycle System without parallel apparatus.

What the system does that no individual framework does is provide the complete information-flow apparatus for any Ora work. PFF alone formalizes processes but cannot tell you whether the process is feasible. PIF alone tells you about feasibility but cannot formalize the process when it’s known. CFF alone organizes corpora but cannot specify what reads from them or writes to them. OFF alone specifies outputs but cannot organize the information they render from. TMF alone maps terrain but cannot tell you what to do with the map. DCA alone handles wicked problems but cannot tell you whether a problem is wicked or formalizable. Together, the six frameworks cover the full information lifecycle — from “I don’t know what shape this work takes” (TMF) through “I know what I want but don’t know how to do it” (PIF) through “I know how to do it and want it to run reliably” (PFF) through “I need to organize the information” (CFF) through “I need to render the information for consumption” (OFF) through “the decision is genuinely irreducible” (DCA). Every kind of information work has a home in the system.

Systemic context

The Information Lifecycle System operates on the substance of work; the Strategic Supervision System supervises the strategic intent that frames the work; the Coordination Layer enforces the locks at runtime; the Matrix Lifecycle System provides the matrix backbone the work lives in. The Information Lifecycle System is invoked from multiple places. Strategic Supervision invokes TMF when MOM determines the problem is not yet definable (Outcome 2 — terrain not yet mapped). Strategic Supervision invokes PIF for P-Feasibility verification of Active milestones (M-Supervised mode). Strategic Supervision invokes PFF when a stable process needs formalization. The Matrix Lifecycle System’s Operations declare consumption of CFF-formalized corpora and produce OFF-formalized outputs. The Coordination Layer’s Process Coherence supervises CFF section writes (E8) and OFF rendered artifacts (E10) at workflow-level events. The Information Lifecycle System reads but does not modify the Knowledge Production System’s artifacts — MindSpec is consumed by IIF (which is in the Matrix Lifecycle System); KAC produces engrams that may flow into corpora; the Creativity reference frames the system’s understanding of how value-filtered combination relates to recognition.

Constituent frameworks

Process Inference (PIF) — the feasibility evaluator. Discovers whether a viable process exists for moving from input to a testable endpoint when the process itself is unknown. Two modes — P-Inference (full process discovery) and P-Feasibility (lighter feasibility check, used by MOM in M-Supervised mode for Active milestone P-Feasibility verification). Produces verdicts in four shapes: Reachable (process exists; can be formalized); Reachable with apparatus to build (process exists but requires preceding work to instantiate); Unreachable under current constraints (no viable process exists; constraints would need to change); Cannot determine without exploration (the territory is unmapped; hand off to TMF).

Process Formalization (PFF v2.0) — the process formalizer. Meta-framework that takes a known process and produces a bespoke framework that runs the process reliably across executions. F-Design produces the framework; F-Execute runs it; the framework artifact has its own Input Contract, Output Contract, Layers, Persona, Evaluation Criteria, Named Failure Modes. Most of Ora’s runtime frameworks were produced via PFF (including some used by this system itself — CFF and OFF were both PFF-designed). The framework is the system’s productivity multiplier — a single PFF design produces a runnable framework that handles thousands of subsequent executions.

Corpus Formalization (CFF v1.1) — the corpus formalizer. Meta-framework that takes a need to accumulate information between processes (an editorial corpus, a research-notes corpus, a customer-data corpus, a tax-cycle corpus) and produces a template plus the first instance. C-Design produces the corpus template (sections, schema, validation rules, cadence, primary-curator marker, cross-section consistency rules). C-Instance produces a new instance from a template. Corpora are independent CFF entities; matrices declare consumption of corpora rather than owning them. Operation-coordination semantics added in v1.1 (2026-05-08): primary-curator markers on corpora; consumption-declaration semantics in matrices; multi-consumer cases handled by primary-curator precedence; archival and schema disputes escalate to DCA when contested.

Output Formalization (OFF v1.1) — the output formalizer. Meta-framework that takes a need to render information for consumption (a daily edition, a quarterly report, a synthesis essay, a digest) and produces a specification with cadence rule, source-corpora declarations, consumer-facing format requirements, and rendering-pipeline references. O-Design produces the output specification; O-Render produces an artifact from the specification. Outputs are independent OFF entities; matrices declare which outputs they produce. Operation-coordination semantics added in v1.1 (2026-05-08): cadence-of-production on outputs may differ from the Operation’s overall cadence; OFF rendered artifacts trigger Process Coherence at workflow-level event E10.

Terrain Mapping (TMF) — the unknown-territory mapper. Handles the case where the problem is not yet definable enough for MOM to produce a Mission, Objectives, and Milestones structure. Produces a Terrain Map Artifact — a structured representation of what’s known, what’s unknown, what the questions are, what the candidate categorizations are, what the relevant prior work is. Once the terrain is mapped, MOM can typically produce a real classification and the rest of the system can proceed. Invoked from PEF Layer 5’s Gap-to-Action Routing when MOM’s Outcome 2 (terrain not yet mapped) fires; also invoked directly when a user knows they are in unmapped territory.

Decision Clarity Analysis (DCA) — the wicked-problem handler. Handles the case where a decision involves irreducible value conflicts, contested definitions, or genuinely unresolvable uncertainty — where producing a false resolution would mislead the user into action that does not actually address the underlying problem. Produces a Decision Clarity Document that names what’s known, what’s contested, what’s irreducible, what the candidate framings are, what the next-best action is given irreducible uncertainty. Auto-fires from Process Coherence on multi-owner conflict patterns (per Operations Manifest Stress Test 8); also invoked directly when a user knows they are facing a wicked problem.

End-to-end worked example

Scenario. A user is starting a research project. They want to investigate how independent builders find their first ten paying customers. They have a clear interest, vague sense of the work shape, no clear deliverable yet, no existing process to follow. Walk through how the Information Lifecycle System organizes the work.

Phase 1 — TMF / Terrain Mapping. The user invokes PEF in PE-Init mode. MOM runs Layer 1 classification: the user’s description is not specific enough to pass the Project Test (“what is the primary tangible deliverable?”); the Operation Test (“recurring deliverables on a cadence?”) is not invoked; the Incubator Test (“central driving question?”) passes — the Critical Unknown is “What is the actual playbook for indie builders moving from technical product to first ten paying customers?” MOM Layer 1 classifies as Incubator. But MOM Layer 2 cannot yet produce a stable strategic-layer — the user does not know enough about the territory to name what the matrix should contain. MOM produces Outcome 2 (terrain not yet mapped). PEF Layer 5 dispatches to TMF.

TMF runs against the question. The Terrain Map Artifact produced organizes the territory: what’s known (a small body of practitioner literature on indie-hacker customer acquisition; a few well-known case studies), what’s unknown (whether the customer-acquisition pattern differs from consultative sales; whether technical-founder-specific failure modes exist; whether the playbook varies by product category), what the questions are (the four candidate research questions worth investigating), what the candidate categorizations are (the work could become a research project producing a synthesized e-book; could become a newsletter operation publishing weekly; could become a deeper Incubator with more reading required), what the relevant prior work is (a list of books, articles, podcast episodes worth reviewing first).

The Terrain Map gets attached to the Incubator matrix. PEF re-invokes MOM with the now-mapped terrain. MOM Layer 2 can now produce a stable strategic-layer — the Incubator’s Critical Unknown is sharpened to “What is the actual indie-builder customer-acquisition playbook, distinguished from consultative-sales patterns and segmented by technical-founder-specific failure modes?” The matrix is now ready for Incubator-stage exploration.

Phase 2 — Reading and corpus formation. The user begins reading the prior-work list. As notes accumulate, a corpus need emerges. The user invokes CFF in C-Design mode.

CFF runs against the need. The user wants a research-notes corpus that accumulates synthesized one-paragraph notes on each source, organized by research question, with cross-references between notes, and updated as new sources are added. C-Design produces the corpus template: sections (one per research question), schema per section (source citation, one-paragraph synthesis, cross-references, status — to-read / reading / synthesized), cadence (event-driven on each new source), primary-curator marker (the user’s research Incubator), cross-section consistency rules (each cross-reference must point to an existing note).

C-Instance produces the first instance — Engrams/Corpora/Indie Builder Research Notes.md (or similar; CFF determines the path). The user’s Incubator matrix declares consumption of the corpus.

Phase 3 — Synthesis pattern emerges; PFF formalizes. After 30 sources, a synthesis pattern starts to emerge — every time the user finishes a section’s worth of notes, they want to write a synthesis paragraph that names the cross-cutting pattern. They’ve done it informally three times; it’s becoming a recurring need. The user invokes PFF in F-Design mode against the pattern.

PFF runs. The pattern is a process: input is “a section’s worth of synthesized notes”; output is “a one-page synthesis paragraph naming the cross-cutting pattern, with citations.” F-Design produces a bespoke framework — Framework — Section Synthesis.md — with Input Contract (the section’s notes; the section’s Critical Unknown), Output Contract (the synthesis paragraph; the citations; a flagged-for-iterate signal if the synthesis surfaces new questions worth adding to the Incubator’s Open Questions), Layers (read all section notes; identify the cross-cutting pattern; draft the synthesis; verify citations; produce the artifact), Persona, Evaluation Criteria, Named Failure Modes. F-Execute runs it on the first section’s notes. The synthesis paragraph lands in the corpus’s section header; the user reviews and approves; the framework runs again on subsequent sections as their notes mature.

Phase 4 — Output design; OFF specifies the synthesis e-book. The Incubator’s Critical Unknown starts to feel close to resolution. The user can see the playbook taking shape across the synthesized sections. The Incubator passes through MOM Layer 1 reclassification — the work becomes a Project, with Resolution Statement “Synthesis e-book on the indie-builder customer-acquisition playbook is published.” The matrix’s project_type updates from incubator to project. PEF / MOM re-populate the strategic layer per Project shape. The Project’s deliverable is an e-book; the user invokes OFF in O-Design mode.

OFF runs. The output is an e-book; the source corpora are the research-notes corpus plus the user’s MindSpec (for voice consistency); the consumer-facing format is PDF + EPUB + print-on-demand-ready manuscript; the cadence is one-time (the e-book ships once at Project terminal milestone); the rendering pipeline is the user’s existing markdown-to-print toolchain. O-Design produces the output specification. The Project Matrix declares the e-book as its produced output.

Phase 5 — Wicked decision; DCA handles the audience question. Two months into Project execution, the user faces a wicked-problem decision. Should the e-book be priced free (maximizing distribution; no revenue), or paid (smaller audience; sustainable income for further work)? The decision involves irreducible value conflicts (distribution vs. sustainability; gift economy vs. compensated craft); the user is genuinely uncertain. Pricing the e-book free could be a mistake if the work is genuinely worth sustaining through subsequent editions; pricing it paid could be a mistake if the audience-building benefits of free distribution are larger than realized. The user invokes DCA.

DCA runs. The Decision Clarity Document organizes: what’s known (audience size estimates from similar e-books in the category; the user’s existing reach; the cost structure of sustaining the work); what’s contested (whether free distribution genuinely builds future commercial reach for indie-published work; whether the audience for paid work cares about a paid signal); what’s irreducible (the user’s value conflict between distribution and sustainability cannot be resolved by more data — it requires a values-based decision); what the candidate framings are (free with optional pay-what-you-want; paid with a free chapter excerpt; paid with delayed free release after one year; etc.); what the next-best action is given irreducible uncertainty (commit to one choice for this edition; treat the choice as a Working Assumption with a one-year revisit trigger; review actual data after one year to inform the next edition’s pricing decision).

The user picks the second option (paid with a free chapter excerpt) as a Working Assumption. The Decision Log records the decision with full reasoning; the revisit trigger is set; the work continues. DCA terminates ephemerally.

Phase 6 — Project ships, Operation conversion considered. The e-book ships at Project terminal milestone. PEF Layer 5’s Promotion Protocol fires the Project closure conversion gate (covered in Strategic Supervision System and Matrix Lifecycle System). The user considers whether the work continues producing value — the audience exists, follow-up editions are possible. They convert in place via OM-Convert. The Project Matrix becomes an Operation Matrix; the e-book becomes an annual Coordinated Output (with the underlying research-notes corpus continuing to accumulate, and a future synthesis cadence formalized via PFF when the pattern stabilizes).

That is one piece of work moving through the Information Lifecycle System. TMF mapped the territory when the problem wasn’t yet definable; CFF formalized the corpus that accumulated the research; PFF formalized the synthesis process when the pattern emerged; OFF specified the e-book output; DCA handled the wicked pricing decision; PIF was implicit in MOM’s M-Supervised P-Feasibility verification (every Active milestone passed through it). The system organized the substance of the work at every stage.

How to compose this system

You can run the Information Lifecycle System pattern with any AI of your choice using the relevant framework specifications and the system’s organizing principle (input → corpus → output, with TMF for unmapped territory and DCA for wicked problems).

For the most common composition — formalizing a process, designing a corpus, specifying an output — the prompt is per-framework rather than system-wide. The user picks which framework matches the immediate need, pastes that framework’s specification, and runs the relevant mode.

For the cross-framework chain (e.g., a process produces output that lands in a corpus that another process consumes), the composition is iterative — design each framework separately; declare the consumption and production relationships explicitly in the matrix; let the Coordination Layer supervise the workflow-level events at the seams.

A complete prompt for one stage (CFF C-Design):

[Paste the Corpus Formalization specification]

Run C-Design.

Corpus need: [Plain prose describing what information needs to accumulate, between which processes, on what cadence, who’s curating.]

[Optional: paste related framework specs that will consume from or produce into this corpus, so C-Design knows the consumption-declaration semantics.]

The AI returns the corpus template (sections, schema, cadence, primary-curator marker, cross-section consistency rules) and the first instance.

For TMF specifically, the prompt is:

[Paste the Terrain Mapping specification]

Run TMF against this question: [Plain-prose description of the territory.]

Produce the Terrain Map Artifact.

The AI returns the structured map (what’s known, what’s unknown, what the questions are, what the candidate categorizations are, what the relevant prior work is).

For DCA, the prompt is:

[Paste the Decision Clarity Analysis specification]

Run DCA against this decision: [Plain-prose description of the decision and the value conflicts in play.]

Produce the Decision Clarity Document.

The AI returns the structured document (known, contested, irreducible, candidate framings, next-best action).

The system as a whole is best run incrementally — invoke each framework as the work calls for it; let the matrix backbone (managed by the Matrix Lifecycle System) carry the connections between frameworks across the work’s lifetime.

What this system enables

What the Information Lifecycle System does that the constituent frameworks alone do not is provide the complete information-flow apparatus for any Ora work, at any scale of organizational complexity. Three things become possible with the system that are not possible with the parts in isolation:

The full input → corpus → output unit, composed at any scale. PFF alone formalizes a single process; CFF alone formalizes a single corpus; OFF alone formalizes a single output. The system composes them — a process formalized by PFF can declare consumption of a CFF-formalized corpus and produce an OFF-formalized output; multiple processes can chain through multiple corpora across multiple matrices. The composition is what supports both the “single process, single output” simplicity of small work and the “multiple processes through multiple corpora producing multiple outputs across multiple matrices” complexity of larger work like the Main Street Independent publication.
A home for unmapped territory and wicked problems. TMF and DCA are the system’s frontier handlers — the frameworks that handle the cases where the rest of the system would prematurely formalize. Without TMF, premature formalization would commit work to a Mission/Objectives/Milestones structure when the territory is genuinely unknown. Without DCA, premature resolution would commit work to a false answer when the underlying question is genuinely irreducible. Both are explicit “the system knows what it does not know” handlers; both prevent the most common failure modes of overconfident formalization.
Operation-coordination semantics that integrate with the matrix backbone. CFF v1.1 and OFF v1.1 added Operation-coordination semantics in 2026-05-08 — corpora declare primary-curator markers; matrices declare consumption; outputs declare cadence-of-production that may differ from the Operation’s overall cadence. This was a thin annotation addition (no parallel apparatus invented; CFF and OFF remained the frameworks they were) but it lets Operations integrate cleanly with the Information Lifecycle System without forcing matrices to own corpora or outputs they merely coordinate with. The thin-annotation approach is the system’s way of staying composable as new requirements emerge.

Citations

The Information Lifecycle System draws on several traditions in information architecture and process management. The input-corpus-output unit owes to the data-pipeline literature in software engineering (where data flows through stages with explicit transformations, and intermediate state lives in stores with their own schema and lifecycle). The meta-framework pattern (PFF / CFF / OFF as frameworks that produce other frameworks) draws on metaprogramming traditions in computer science — code that produces code, with the meta-level handling the patterns the object-level cannot. The corpus-as-independent-entity pattern owes to data-modeling literature where shared data lives in independent stores with multiple consumers, rather than being owned by one consumer.

TMF’s terrain-mapping discipline draws on exploratory research methodology (Glaser and Strauss’s grounded theory; Eisenhardt’s case-study methodology) where the territory must be characterized before hypotheses can be formed. DCA’s wicked-problem handling draws on the wicked-problems literature originated by Rittel and Webber (1973) and developed by Conklin and others — problems where stakeholders disagree on the problem definition itself; where every solution attempt changes the problem; where there is no algorithmic terminus.

The Operation-coordination semantics in CFF v1.1 and OFF v1.1 (both 2026-05-08) are internal to Ora and were the awareness-sweep additions made when the Operations Manifest landed; the prior versions handled corpora and outputs without explicit Operation-coordination markers. The framework versions composed here are PFF v2.0, PIF (current), CFF v1.1, OFF v1.1, TMF (current), and DCA (current); per-framework citations will live in the per-framework papers when drafted.

Open problems

Feasibility and wickedness are model judgments, not proofs. PIF’s Reachable/Unreachable verdict and DCA’s “this problem is irreducible” determination are the system’s frontier handlers, but each is the model’s assessment. A wrongly-Unreachable verdict abandons a workable problem; a wrongly-wicked verdict refuses to formalize one that was actually tractable.
Reliability amplifies a bad spec. A PFF-designed framework runs the process as described. If the description is wrong, the formalized framework runs the wrong process reliably across thousands of executions — the meta-framework’s strength becomes a liability when the input process is mis-specified.
Consumption coordination is declared, not detected. Matrices declare which corpora they consume and corpora carry primary-curator markers, but a consumer that fails to declare, or a curator marker set wrong, produces a coordination gap the system cannot see — the topology is only as correct as the declarations.
The TMF→formalization handoff has no objective trigger. “The terrain is now mapped well enough to define a problem” is a judgment, not a measurable threshold. Exit too early and the premature-formalization failure TMF exists to prevent recurs one layer down.