Filix v1.0 — Architecture Plan

Filix is the clean-start successor to HAAK. Same intellectual system — externalized reasoning workspace where everything is written to disk, indexed, auditable — but rebuilt from scratch with three…

Agent-agnostic: The constitutional layer works with any AI platform, not just Claude Code.
Platform-independent: Three-tier degradation — any agent can navigate (Tier 1), capable agents execute skills (Tier 2), Claude Code orchestrates multi-agent workflows (Tier 3). Signal connector for mobile. Browser workspace in v1.1.
Constitutionally grounded: The constitution is ontologically sound and designed for cryptographic verification (v2.0). Machine-readable assertions with audit scripts in v1.0.

Named for filesystem + Unix suffix. Logo treatment: FiLiX.

#1. Approach: Clean Start

New repository at ~/projects/filix/. Not a fork. Reasons:

HAAK's git history carries binary blobs (PDFs, PPTX, DOCX, iPhone backup refs) — hundreds of MB unreachable
ZM-specific content woven into every commit — scrubbing is harder than copying
The reorganization is substantial enough that cross-boundary diffs are meaningless
Privacy: personal data deeply embedded in history

HAAK becomes archival. Filix starts with a clean first commit containing the constitutional layer.

#2. Architecture

#The system layer (fully portable)

Filix IS its directory tree. Pure markdown + indices. No platform dependency. Any agent that reads files can navigate, understand, and work within the system.

Directory	What	Ontological axis
`foundations/`	Why the system is shaped this way	— (meta: grounds the axes)
`ontology/`	What exists and how things relate	— (meta: defines the axes)
`patterns/`	How it works — architecture, policies, methods, skills	Method axis
`personas/`	Who speaks — profiles, agents	Actor axis
`styles/`	How prose is structured	Method axis (writing)
`projects/`	Where work happens	Domain axis
`strategy/`	What to do next	— (meta: directs attention)
`references/`	Shared knowledge (attribution, guidelines)	— (materials)

Agents nest under personas/agents/ because agents are actor-types — executable capability profiles. Skills nest under patterns/skills/ because skills are method-types at finest grain. This maintains axis integrity: everything Actor is under personas/, everything Method is under patterns/. The distinction between a persona profile and an agent definition is executability, not ontological kind.

Lifeline and strategy: lifeline.md is the session-level expression of the user's current state and intent — a situation-trace of the user at finest temporal grain. strategy/ holds durable goal-directed plans — the user's engagements at coarser temporal grain. Both carry the "fourth axis" (why, Foundation 00) at different resolutions.

Engagement state: The third externalization identified in Foundation 07 — tracking phase position, accumulated obligations, and goals of ongoing engagements — has no structural home yet. In v1.0, engagement state is carried informally in board entries and project directories. A formal convention (probably engagement.md files within project directories, alongside board.md) is deferred to post-v1.0 but designed for: the constitution's type system names engagements, and the project directory structure has room for them.

#Skill definitions vs. transport adapters

A skill is a method-type defined in SKILL.md — portable, constitutional content. An MCP server wrapper (server.py) is a transport adapter that exposes the skill for remote invocation. These are ontologically distinct:

SKILL.md = what the method does (inputs, steps, constraints). Portable — any platform can read it.
server.py = how the method is invoked at runtime. Infrastructure — tied to MCP protocol.

A fork that uses a different agent platform should be able to use every SKILL.md without any server.py. The skill definition is constitutional; the transport adapter is operational.

Two categories of skills:

Category	Examples	MCP wrappable?	v1.0 scope
Mechanical	commit, pdf-to-md, capture, hak-pdf, contacts	Yes — thin wrappers around shell commands	Wrap now (~10 skills)
Agentic	review, write, read, engage, style, search	No — require agent loops, branching on content, persona loading	SKILL.md as system prompt only

Agentic skills are irreducibly agent-loop dependent. An MCP server for /review would need to spawn an agent, which defeats the purpose. They remain SKILL.md-as-system-prompt, consumed by whatever agent platform is active.

#Platform machinery (swappable)

Runtime configuration specific to each AI platform. Only one is active at a time.

Directory	What	Platform
`.claude/`	Settings, hooks, session state	Claude Code
`.cursor/`	Rules, scoped configurations	Cursor
`.openai/`	Codex configuration	OpenAI Codex

Each platform directory is independent. Swapping platforms = activating a different directory. The system layer doesn't change.

#Platform independence tiers

Not every agent platform can do everything. Filix degrades gracefully:

Tier	Requirement	Capability	Who qualifies
Tier 1	Reads files	Navigate indices, read content, understand structure	Any LLM with file access
Tier 2	Reads files + executes tools	Run mechanical skills, update indices, write content	Claude Code, Cursor, Codex, Gemini CLI
Tier 3	Reads files + executes tools + spawns agents	Run agentic skills, multi-agent orchestration, review panels	Claude Code (currently), potentially Cursor with agent support

A system that works at Tier 1 is the floor. Everything above that is capability extension.

#The bootstrap chain

AGENTS.md          → Universal behavioral bootstrap (all platforms read this)
  ↓ references
CLAUDE.md          → Claude-specific extensions (model prefs, MCP config, hooks)
  ↓ loads
.claude/settings   → Runtime permissions and state

AGENTS.md replaces the portable content currently in HAAK's CLAUDE.md: navigation instructions, document conventions, interaction protocols, coordination rules. CLAUDE.md starts with "Read AGENTS.md first" and retains only Claude-specific content: conda paths, MCP server configs, session hooks, model preferences.

#Design-for-crypto

Filix v1.0 designs for cryptographic verification without implementing it. The constitutional format includes a proof: field (null in v1.0). Skill traces follow a convention that future SCMP integration can verify. Remote board transport is designed as pluggable. Specifically:

Constitution frontmatter carries requirements: blocks with check: (human-readable) and audit: (script path) and proof: (null) fields
Every skill trace includes: skill name, inputs hash, outputs hash, timestamp, actor — fields that a future cryptographic commitment scheme can sign
Board entries carry a transport: field (default: local) that a future remote sync protocol can use
The Signal connector (v1.0) is the first non-local transport — boards and files move between devices via encrypted channel

#3. Directory Structure

filix/
├── AGENTS.md                  # Universal bootstrap (all platforms)
├── CLAUDE.md                  # Claude-specific extensions
├── index.md                   # Root navigation
├── lifeline.md                # User trajectory (template)
├── board.md                   # Coordination bus (template)
│
├── foundations/                # Why (8 docs from HAAK, renamed)
│   ├── 00-why.md
│   ├── 01-core-thesis.md
│   ├── 02-library-theorem.md
│   ├── 03-institutional-intelligence.md
│   ├── 04-science-ecosystem.md
│   ├── 05-externalization.md
│   ├── 06-three-axis-model.md
│   ├── 07-coordination-topology.md
│   └── index.md
│
├── ontology/                  # What exists (copy from HAAK)
│   ├── 01-objects.md
│   ├── 04-correspondence_v1-2.md
│   ├── 05-perception-memory.md
│   ├── 06-ai-writing-scenario.md
│   ├── 07-correspondence-filix.md    # Adapted: HAAK → Filix mapping
│   ├── 08-relational-ground.md
│   └── index.md
│
├── patterns/                  # Method axis
│   ├── architecture/          # ~20 docs (adapted from HAAK)
│   ├── policies/              # Constitution + 5 policies (adapted)
│   ├── methods/               # ~16 method docs (adapted)
│   ├── skills/                # FLAT — all skills, categorized by index.md
│   │   ├── read/              #   Core
│   │   ├── write/             #   Core
│   │   ├── commit/            #   Core
│   │   ├── review/            #   Core
│   │   ├── style/             #   Core
│   │   ├── search/            #   Core
│   │   ├── capture/           #   Core
│   │   ├── engage/            #   Core
│   │   ├── board/             #   Core
│   │   ├── todo/              #   Core
│   │   ├── signal/            #   Connector (v1.0)
│   │   ├── email/             #   Connector
│   │   ├── calendar/          #   Connector
│   │   ├── contacts/          #   Connector
│   │   ├── whatsapp/          #   Connector
│   │   ├── papers/            #   Connector
│   │   ├── lit-search/        #   Connector
│   │   ├── pdf/               #   Format
│   │   ├── pdf-to-md/         #   Format
│   │   ├── pptx/              #   Format
│   │   ├── docx/              #   Format
│   │   └── index.md           # Categorized: Core / Connectors / Formats
│   ├── features/              # Development records
│   └── index.md
│
├── personas/                  # Actor axis
│   ├── profiles/              # Voice, expertise (pure markdown)
│   │   ├── _template.md       # Example persona showing format
│   │   └── index.md
│   ├── agents/                # Executable role definitions
│   │   ├── editor.md
│   │   ├── reviewer.md
│   │   ├── reviewer-noinscription.md
│   │   ├── writer.md
│   │   ├── architect.md
│   │   ├── copy-editor.md
│   │   ├── auditor.md
│   │   ├── librarian.md
│   │   └── index.md
│   └── index.md
│
├── styles/                    # Writing style definitions
│   ├── axiomatic.md
│   ├── advisory.md
│   ├── formal-review.md
│   ├── window-themes.yaml
│   └── index.md
│
├── projects/                  # Domain axis — users populate
│   ├── _template/             # Example project scaffold
│   │   ├── index.md
│   │   ├── board.md
│   │   └── sources/
│   └── index.md
│
├── strategy/                  # Meta — directs attention
│   └── index.md
│
├── references/                # Shared knowledge (materials)
│   ├── ai-attribution.md
│   ├── skill-guidelines.md
│   ├── agent-guidelines.md
│   └── index.md
│
├── console/                   # v1.1 — browser workspace
│   └── README.md              # Scaffold only in v1.0
│
├── ops/                       # Operational infrastructure
│   ├── daemons/               # Background services (signal-bot, etc.)
│   ├── scripts/               # Utility scripts (init.sh, audit-*.py)
│   ├── launchd/               # macOS launchd plist templates
│   └── index.md
│
├── .claude/                   # Platform: Claude Code runtime
│   ├── settings.json          # Points skills_dir, agents_dir at promoted paths
│   ├── hooks/
│   └── scripts/
│
├── data/                      # Instance data (gitignored except schema)
│   ├── .gitkeep
│   └── schema/                # Database schemas (tracked)
│       ├── contacts.sql
│       ├── papers.sql
│       ├── files.sql
│       └── ...
│
└── downloads/                 # Transit area (gitignored)

#Key structural decisions

Skills flat under patterns/skills/ — no core/connectors/formats/ subdirectories. Categorization lives in skills/index.md section headers, not path structure. This avoids baking a mutable classification into paths that dozens of cross-references depend on. If a skill moves from "connector" to "core," only the index changes — not every file that references it.

Agents under personas/agents/ — agent definitions are actor-types (executable capability profiles). Keeping them on the Actor axis alongside persona profiles maintains axis integrity. The distinction between a profile (voice, expertise, bibliography) and an agent (tools, delegation rules, system prompt) is executability, not ontological kind.

data/schema/ tracked, data/ gitignored — database schemas are constitutional (they define what the system can store). Actual data is instance-specific. A fresh clone creates empty databases from the schema files via ops/scripts/init.sh.

.claude/settings.json points at promoted paths — Claude Code discovers skills from .claude/skills/ and agents from .claude/agents/ by default. After promotion, settings.json must set skillsdir: "patterns/skills" and agentsdir: "personas/agents". Without this, Claude Code won't find them.

ops/ carries last-verified: convention — every file in ops/ includes a last-verified: date in its header comment. During /audit, anything unverified for >90 days gets flagged. Prevents accumulation of dead scripts.

console/ is scaffolded in v1.0, built in v1.1 — v1.0 ships a README describing the planned architecture. The console is a filesystem viewer that coexists with Claude Code, not a replacement. Claude Code remains the primary agent runtime. The console watches the filesystem and reflects changes in the browser.

Project registry with local overrides — projects/registry.yaml (tracked) holds internal projects. projects/registry.local.yaml (gitignored) holds machine-specific external paths. Skills that traverse projects read both.

#4. What Gets Copied from HAAK

#Copy as-is (rename HAAK → Filix throughout)

foundations/ — all 8 docs
ontology-objects, 04-correspondence_v1-2.md, 05-perception-memory.md, 06-ai-writing-scenario.md, 08-relational-ground.md
design-principles, 08-encapsulation.md, 09-recursive-index.md, 10-readwrite.md
styles/ — all 3 style definitions + themes
references/ — ai-attribution, skill-guidelines, agent-guidelines

#Adapt (structural changes during copy)

ontology-correspondence-haak → 07-correspondence-filix.md — rebuild mapping against new structure
patterns/policies/01-constitution.md — revise type system to align with ontology (see Section 5 sub-steps)
forkability — rewrite for Filix's architecture
context-transport — remove references to unbuilt HAAK components
All ~46 SKILL.md files — rename HAAK → Filix, update paths (move from .claude/skills/ → patterns/skills/)
All 9 agent definitions — rename, update paths (move from .claude/agents/ → personas/agents/)
CLAUDE.md → split into AGENTS.md (portable) + CLAUDE.md (Claude-specific, starts with "Read AGENTS.md first")

#Leave in HAAK (instance data)

mainen-lab/ — all lab science
projects/ contents — all active projects (can be imported later as external repos)
strategy/ contents — ZM's strategic plans
data/ — all databases, media, backups
downloads/, transcripts/
personas/ — all 65+ personas (keep template only)
web/, site/ — HAAK-specific web presence
Board entries, lifeline content

#5. Constitution

The constitution is the most ontologically consequential artifact in the system. v1.0 ships the document — well-written, ontologically grounded, structurally sound. v2.0 adds programmatic verification (SCMP, inscription proofs).

#5a. Constitutional revision (v1.0)

The current HAAK constitution's type system diverges from the ontology in five ways identified by the correspondence document. The revision addresses each:

Ground terms in the ontology — every type in the constitution maps to a definition in ontology-objects. The constitution references the ontology explicitly.
Unify skills under method-types — skills are method-types at finest grain, not a separate ontological kind. The constitution's type system reflects this.
Reclassify foundations as materials — foundations are materials carrying policy-grounds (ontology Def. 5), with a separate directory for pragmatic reasons. The constitution names this.
Add patterns to the type system — "Patterns = descriptive type-compounds — observed regularities in how situations of a given kind tend to unfold. Patterns are promoted to policies through the maturity gradient (observed → stable → enforced)."
Make the domain forest explicit — the directory hierarchy IS the domain hierarchy; policies accumulate through subsumption. The constitution declares this.

#5b. Machine-readable assertions (v1.0)

The constitution carries requirements: blocks in frontmatter with machine-readable assertions:

requirements:
  externalization:
    check: "every skill writes output to disk before returning"
    audit: "ops/scripts/audit-externalization.py"
    proof: null  # v2.0: cryptographic commitment
  human_authority:
    check: "no skill modifies policy without human approval"
    audit: "ops/scripts/audit-authority.py"
    proof: null
  ai_attribution:
    check: "every AI-generated document has attribution frontmatter"
    audit: "ops/scripts/audit-attribution.py"
    proof: null

v1.0 ships 2-3 concrete audit scripts for the simplest requirements (attribution check, index completeness check). More complex checks (externalization verification, authority verification) ship as documented requirements with audit: TODO markers. Partial verification is better than no verification or fake verification.

#5c. Inscription proofs (v2.0)

The full inscription architecture from SCMP: constitutional compliance proofs using cryptographic commitments. Each method step produces a trace. The trace is verifiable against the constitution's requirements. This is the Paper 2 contribution. The proof: null fields in the v1.0 constitution are the designed insertion points.

#6. Interfaces

#v1.0: Signal connector (phone bridge)

The first non-local transport. A Signal bot daemon (ops/daemons/signal-bot/) running signal-cli bridges Filix to any phone. This is the v1.0 mobile solution — no browser workspace, no native app, just encrypted messaging to a running Filix instance.

What it does:

Send files to Filix (PDFs, photos, voice memos → routed by /capture)
Receive board updates and agent output
Send quick text that routes to appropriate skill (capture, todo, search)
File send/receive works both directions

Architecture:

Phone (Signal app) ←→ signal-cli daemon ←→ Filix filesystem
                                          ├── downloads/ (incoming)
                                          ├── board.md (push updates)
                                          └── patterns/skills/signal/ (skill def)

Why Signal, not a custom app: Signal protocol gives end-to-end encryption for free. The bot is a ~200-line Python daemon. No app store, no React Native, no authentication system. The user already has Signal on their phone. This is the minimum viable mobile bridge.

The skill at patterns/skills/signal/ handles the Filix side. The daemon at ops/daemons/signal-bot/ handles the transport. The launchd template at ops/launchd/ keeps it running.

#v1.1: Browser workspace

Custom React application. Not a chat window — a knowledge navigation and coordination surface. A filesystem viewer that coexists with Claude Code, not a replacement. Claude Code remains the primary agent runtime. The console watches the filesystem and reflects changes in the browser.

Stack: FastAPI (Python) + React/Vite/Tailwind + WebSocket for real-time updates. Filesystem watcher with 100ms debouncing (a git operation touching 50 files pushes one batch update, not 50 events).

Views: Navigator (index trees), Board (coordination timelines), Document (markdown with frontmatter + backlinks), Chat (lightweight agent interaction — delegates to Claude Code for heavy lifting).

#v1.2: 3D topology + mobile

3D topology (React Three Fiber): Renders the inter-axis topology — agents as trajectories through Actor × Method × Domain space, situations glowing at intersections, time slider for history. This is a projection of the ontology, not a lossless rendering: it captures the between-axis structure (how actor, method, and domain combine in situations) but compresses within-axis structure (domain trees, method graphs, actor hierarchies). Those require the other views — Navigator for trees, Thread Graph for dependencies, Board for timelines. Together, all views render the ontology. The 3D topology alone renders the situational cross-section.

Mobile PWA: Same React app, responsive layout. PWA manifest + service worker for offline caching. Use cases: read boards, navigate indices, review agent output, quick capture.

#7. Project Model

Two modes, both fully supported:

#Internal projects

Directories inside projects/ in the Filix repo. Indexed, board-tracked, governed by the constitution. If the repo is private, this is fine.

#External projects

Separate repos or directories that follow Filix conventions (index.md, board.md, standard structure). Referenced via a project registry:

# projects/registry.yaml (tracked — internal projects only)
internal:
  - path: projects/my-paper
    type: manuscript

# projects/registry.local.yaml (gitignored — machine-specific external paths)
external:
  - name: mainen-lab
    path: ~/projects/haak/mainen-lab
    type: lab
  - name: inscription-agents
    repo: git@github.com:zmainen/inscription-agents.git
    type: research

The registry is the cross-boundary equivalent of the root index — it extends the domain forest across repository boundaries. Skills that traverse projects read both files. /read and /write work on both internal and external projects. External projects can be private repos, submodules, or symlinked directories.

#8. Execution Sequence

#Phase 1: Scaffold

Create ~/projects/filix/ — git init
Write AGENTS.md — split from current CLAUDE.md (portable content)
Write CLAUDE.md — Claude-specific extensions only, starts with "Read AGENTS.md first"
Write index.md — root navigation
Create template files: lifeline.md, board.md
Create full directory structure (empty index.md in each directory)

#Phase 2: Constitutional layer

Copy foundations/ — rename HAAK → Filix throughout
Copy ontology/ — adapt 07-correspondence for new structure
Copy patterns/architecture/, patterns/methods/ — adapt for new paths
Copy styles/
Copy references/
Write constitution v2 — the most consequential step. Sub-steps:

12a. Ground terms in ontology-objects
12b. Revise type system (unify skills under method-types, reclassify foundations as materials, add patterns as descriptive type-compounds)
12c. Add domain-forest declaration (directory hierarchy = domain hierarchy, policy subsumption)
12d. Add machine-readable assertions with proof: null fields
12e. Write 2-3 audit scripts for simplest requirements (attribution check, index completeness)

#Phase 3: Agent + skill layer

Create HAAK-to-Filix migration inventory — every HAAK skill, agent, architecture doc, and method, with a disposition column (copy / adapt / skip / defer). Archive the inventory in strategy/.
Copy agents → personas/agents/ — update all role definitions, paths
Copy skills → patterns/skills/ (flat) — update patterns/skills/index.md with Core / Connectors / Formats section headers
Update all ~46 SKILL.md files — rename HAAK → Filix, update paths
Create MCP server wrappers for mechanical skills only (~10: commit, pdf-to-md, capture, contacts, calendar, etc.)
Build Signal connector — patterns/skills/signal/SKILL.md + ops/daemons/signal-bot/ + launchd template
Configure .claude/settings.json — set skillsdir: "patterns/skills" and agentsdir: "personas/agents"
Verification: grep entire repo for residual haak references (excluding .git/ and expected historical references in foundations). Fix any incomplete renames.

#Phase 4: Operational layer

Set up .claude/ — settings, hooks, scripts
Set up ops/ — daemons, scripts, launchd templates (with last-verified: convention)
Set up data/schema/ — database schemas (tracked)
Write ops/scripts/init.sh — bootstrapping script that creates databases from data/schema/ files
Configure .gitignore for data/, downloads/, transcripts/, registry.local.yaml

#Phase 5: Verification + review

Run /audit constitution against the new repo
Run ontology review — check all structural decisions against 01-objects.md
Run architecture review — check encapsulation, drift resistance, forkability
First real project import — bring one HAAK project into Filix as external
Test Signal connector end-to-end (send file from phone → arrives in Filix)

#Phase 6: Polish + ship

README.md — external-facing description
First commit message: "Filix v1.0 — externalized reasoning workspace"
Tag v1.0

#9. Name Replacement Table

Pattern	Replacement
`HAAK`	`Filix` (prose)
`haak`	`filix` (paths, identifiers)
`hak-pdf`	`filix-pdf`
`hak-site`	`filix-site`
`com.haak.*`	`com.filix.*`
`haak.code-workspace`	`filix.code-workspace`
Theodore Haak	Historical footnote in Foundation 09 (origins)

#10. Timeline and Release

Target: August 2026. FiLiX 1.0 releases alongside The Shape of Incompleteness. Same event. The system demonstrates the theory; the book explains it.

Business model: Open source. Fully off-grid, secure, constitutionally managed, vendor invariant. No financial incentives to sell the system. Income from books, courses, and engagements — not software. The open-source philosophy is constitutive: the system cannot be sold because selling it would contradict its own argument about organizational intelligence.

What ships together (August 2026):

FiLiX 1.0 (the system)
The Shape of Incompleteness (the book)
Library Theorem paper (the proof)
Indexed Inconsistency Theorem paper (the meta-proof)

#Integrated project timeline

All projects converge on August 2026. Each both uses and develops Filix. Blockers flow downward — anything that blocks Filix blocks everything downstream.

MAR  APR  MAY  JUN  JUL  AUG  SEP  OCT  NOV
 |    |    |    |    |    |    |    |    |
 ├─── FILIX V1.0 ──────────────┤ SHIP
 │ scaffold│ constitution │skills│ test│
 │         │ + ontology   │migr  │     │
 │         │              │signal│     │
 │                                     │
 ├─── THE BOOK ────────────────┤ PUBLISH
 │ KB build│ writing      │ edit│     │
 │ TTT+NB  │              │     │     │
 │                                     │
 ├── LIBRARY THEOREM PAPER ────┤ SUBMIT (pre-book)
 │ proof   │ write        │     │     │
 │                                     │
 ├── INDEXED INCONSISTENCY ────┤ SUBMIT (w/ book)
 │ experiment│ write       │     │     │
 │                                     │
 ├── LAB PAPERS ───────────────────────│
 │ Solène R2 │ Felix │ Guido │ face-dec│
 │ (accept?) │  R2?  │       │ CurrOpin│
 │                                     │
 ├── BEOWOLFF ─────────────────┤ DEMO
 │ white paper = book          │     │
 │                                     │
 ├── STORY TRAINS ─────────────────────│
 │ ECD conf │ advisory    │ ongoing   │
 │                                     │
 ├── NO BLACK BOXES ───────────────────│
 │ London Apr│             │          │
 │                                     │
 ├── TEACHOUT / GOVERNANCE ────│──────────────│
 │          │ first piece │   │ after book   │
 │          │ (summer)    │   │ MIDTERMS NOV │
 └──────────┴─────────────┴───┴──────────────┘
                                  LOW PROFILE → ENGAGE

#Dependencies and blockers

Project	Depends on Filix	Contributes to Filix	Blocker risk
The Book	Uses Filix for research, writing, KB management	The book IS the ontology white paper; drives constitution revision	High — competes for ZM's time. Book writing is the hardest single task.
Library Theorem	Written and reviewed in Filix	Foundation 02; validates the indexing architecture	Low — proof mostly done; writing is bounded.
Indexed Inconsistency	Experiment runs in Filix	Foundation 02 extension; validates the system empirically	Medium — experiment still running; results shape the paper.
Lab papers	All reviewed/edited in Filix (HAAK currently)	Stress-test review, editorial, write skills	Medium — hard deadlines can preempt Filix work. Solène's paper is closest to acceptance.
Beowolff	Pitch deck done; white paper subsumed by book	Validates the "give it away free" strategy	Low — Andrew waits for the book/system.
Story Trains	Uses Filix for neuroscience advisory work	Tests Filix in a non-academic domain	Low — advisory role, not engineering dependency.
No Black Boxes	April London meeting uses Filix as demo	Tests externalization principles with Gonçalo's community	Low — meeting happens regardless of Filix state.
Teachout/governance	First piece uses Filix research capabilities	Paper 6 validates the institutional intelligence argument	Low until summer — deferred by design.

#Critical path

The critical path runs through two items: Filix scaffold + constitution (Phases 1-2, March-April) and the book (March-August). Everything else can absorb delays. If Filix v1.0 slips, the book launch still happens — the system is already running as HAAK. If the book slips, Filix ships without it (the system doesn't need the book to function).

The one hard dependency: lab papers have external deadlines. Journal review timelines don't wait. When a revision request arrives, it preempts everything. Budget ~2 weeks per paper for revision work. With 4-5 active papers, expect 8-10 weeks of preemption across the March-August window.

#Post-August: the engagement phase

Low profile until the book ships. Work through practical applications (lab papers, Story Trains, Beowolff). Don't promote the vision publicly. Let results accumulate.

After August: engage wider audiences. The book provides the intellectual credential. The system provides the demonstration. The papers provide the formal validation.

November 2026 — US midterm elections: The governance conversation (Paper 6, Teachout collaboration) enters its energy window. Regardless of outcome, the midterms produce instability that opens space for institutional alternatives. The message — intelligence is organizational, not technological — lands differently when institutions are visibly failing or visibly succeeding. Either way, the question "how should institutions work?" becomes urgent. FiLiX and the book are the answer.

#Version roadmap

Version	Target	Scope
1.0	Aug 2026	Constitutional layer, skills migration, Signal connector, AGENTS.md, design-for-crypto
1.1	Oct 2026	Browser workspace (Navigator, Board, Document views), mechanical MCP wrappers
1.2	Dec 2026	Mobile PWA, 3D topology visualization, additional connectors
2.0	2027	Constitutional verification (SCMP), inscription proofs, engagement state, multi-platform testing

#11. What This Plan Does NOT Cover

Migrating all HAAK projects to Filix (post-v1.0 — project by project)
SCMP inscription proofs (2.0 scope)
Full constitutional programmatic verification (2.0 scope)
Multi-platform testing (Cursor, Codex adapters — future work)
Browser workspace (1.1 scope)
3D topology visualization (1.2 scope)
Native mobile app (1.2+ scope)

#12. Success Criteria

Filix v1.0 is done when:

A fresh git clone + ops/scripts/init.sh produces a working system with no HAAK dependencies
AGENTS.md boots any MCP-capable agent into the constitutional layer
Core skills work via Claude Code (and could work via MCP from other platforms)
The constitution document is ontologically grounded and structurally sound (all 5 revision sub-steps complete)
Signal connector enables file send/receive and board monitoring from phone
At least one external project (from HAAK) is importable and navigable
The ontology correspondence table (07-correspondence-filix.md) is accurate against the new structure
Design-for-crypto annotations present (proof fields, trace format) even if not implemented
No residual haak references in paths or identifiers (prose historical references are fine)

filix · strategy · 2026-03-04 · zach + claude

Strategy 19 — Filix v1.0 — Architecture Plan — 2026 — Zachary F. Mainen / HAAK