Aevum As-Is Baseline

Date: 2026-04-16

Assessment type: Ground-truth repository baseline

Assessor: Codex

Scope rule: No codebase changes made

1. Executive Summary

Aevum today is a real iOS-first prototype with a meaningful local codebase, on-device persistence, visible UI flows, widgets, App Intents, and a partial localhost inference API. It is not yet the fully unified, deterministic, API-led, tri-surface operating system described in the target vision.

The strongest current working path is:

Dashboard voice/text input -> BehaviourIntelligenceLayer -> InstantProcessor -> MemoryEngine -> SwiftData local store

The weakest and highest-risk area is:

Pipeline-dependent features are implemented in code, but the central IntelligencePipeline is not booted from the normal app startup path. That makes several advertised capture and automation flows present-but-not-baseline-safe.

Current truth:

Real iPhone app: Yes
Real iPad app: Same universal iOS app, not a separate validated product
Real Mac app: No
Local persistence: Yes
Local API: Yes, but narrow and not CRUD-based
Notion integration: Stub/mock only
Shortcuts: Partial
Siri: Stub-level
End-to-end testing system: Not present

Overall program state:

Product maturity: Internal prototype / alpha
Engineering maturity: Mixed
Release readiness: Not ready for controlled public release without scope correction

2. Direct Ground-Truth Answers

2.1 Current Working Components

Item	Status	Ground truth
---	---	---
Aevum iPhone app exists	YES	Real iOS app target exists
Aevum iPad app exists	YES	Same iOS app, not separate iPad product
Aevum Mac app exists	NO	No macOS target found
Local API on localhost	YES	`127.0.0.1:8080`, single prompt endpoint
Notion integration active via API	NO	OAuth and sync are mocked
Apple Shortcuts actively logging data	NO	Intents exist, but logging path depends on unbooted pipeline
Siri integration working	NO	Siri/App Intent exists, but core behavior is stub-level

2.2 Thought Capture - Current Reality

Current thought capture is not one system. It is multiple parallel paths.

Path A: Dashboard voice/text

User speaks or types in the main dashboard
App calls BehaviourIntelligenceLayer.process(...)
Flow writes locally through InstantProcessor and MemoryEngine
Result is persisted in SwiftData

Status: This is the strongest current baseline path.

Path B: Capture Sheet / Import / Habit / Legacy

UI calls IntelligencePipeline.shared.enqueue(...)
Queue should process AevumEvent items and merge into memory graph

Status: Implemented, but not reliable as baseline because the pipeline is not booted in normal app startup.

Path C: Shortcut-triggered dictation

Shortcut sets a UserDefaults launch flag
App polls the flag and opens voice capture

Status: Real and plausible.

Path D: Shortcut direct thought logging

App Intent calls IntelligencePipeline.shared.enqueue(...)

Status: Not baseline-safe for same reason as Path B.

2.3 Data Storage - Current Reality

Primary storage is local.

Current storage layers:

SwiftData / SQLite store on device
UserDefaults / AppStorage for feature and launch state
Local downloaded model files
Local temporary OCR/audio/import files

Current answer:

Notion only: No
Local database: Yes
Both: No, not in real production sense
Something else: Yes, local settings/files alongside database

2.4 Automation - Current Reality

What exists today:

Event queue auto-processing after enqueue
Widget deep link into voice capture
App polling for shortcut dictation flag
Background task code for daily processing
Calendar sync manager

What does not exist as a fully active baseline:

Proven scheduled automation flow
Proven fully wired background synthesis loop
Proven external sync automation
OpenClaw or orchestrated automated validation

Current answer:

Manual only: No
Shortcut-triggered: Yes, partially
Scheduled automation: Partial code only
Any scripts running: No repo-level runtime automation system evidenced

2.5 API - Current Reality

Current answer: Partial API

What exists:

Local listener on 127.0.0.1:8080
Security header key check
POST /aevum
JSON prompt input
Inference text output

What does not exist:

Thought CRUD API
Task API
Goal API
State API
Debug/state validation API as described in the vision

2.6 UI State

Current answer:

Devices are not identical today
They are only conceptually intended to be aligned

Reality:

iPhone and iPad share one iOS codebase
iPad is adaptive, not separately validated
Mac app is absent

2.7 Testing

Current answer:

No structured end-to-end system
Some XCTest / package tests
Manual testing clearly still relied upon

Reality:

Package-level tests exist in several modules
No UI automation suite found
No app-level integration harness found
Some tests appear stale against current source interfaces

3. As-Is Architecture

3.1 Actual Current Topology

```text

[ iOS App UI ]

|-- Dashboard path -> BehaviourIntelligenceLayer -> InstantProcessor -> MemoryEngine -> SwiftData

|-- Capture/import/shortcut path -> IntelligencePipeline -> EventQueueActor -> inference/merge -> SwiftData

|-- On app appear -> Local API listener starts

|-- Widgets / App Intents / deep links -> app entry points

```

3.2 Actual Architectural Layers

UI / Surface layer

App shell
Dashboard
Timeline
Knowledge Map
Settings
Capture sheet
Widgets
App Intents

Orchestration / intelligence layer

BehaviourIntelligenceLayer
IntelligencePipeline
EventQueueActor
InstantProcessor
DailyProcessor

Persistence layer

SwiftData models in CoreMemory
Local file-backed store AevumSecureGraph.store
UserDefaults / AppStorage

Integration layer

EventKit-based native calendar sync
OAuth provider stubs for Google / Outlook / Notion
Localhost inference API
Widget URL deep links
App Intents / Shortcuts

Inference / ML layer

PhiInferenceEngine
MLXExecutionSandbox
local model download and runtime support

4. Actual Feature Inventory

4.1 Product Surfaces Present

Current visible or shipped-like surfaces:

Main iOS app shell
Onboarding flow
Privacy manifesto gate
Biometric lock gate
Dashboard
Timeline view
Knowledge map view
Settings
Capture sheet
Voice capture view
Data ingestion view
Widget bundle
App Intents / Shortcuts

4.2 Actual Feature List With Status

Feature	Status	Notes
---	---	---
Onboarding flow	Implemented	Real UI
Privacy gate	Implemented	Real UI
Biometric unlock	Implemented	Real UI/security layer
Dashboard orb input	Implemented	Real voice/text interaction
Voice transcription	Implemented	Uses Apple speech APIs
Manual text input	Implemented	Via dashboard and capture sheet
Timeline view	Implemented	Real local data-backed UI
Knowledge map view	Implemented	Real UI over system inference nodes
Settings and toggles	Implemented	Real UI with state toggles
Widget quick voice launch	Implemented	Deep-link based
Daily brief widget	Partial	Placeholder/mock content
Local API	Partial	Single inference endpoint
Native calendar context	Partial	Real code path exists
Google calendar sync	Stub	Mock token and mock event injection
Outlook sync	Stub	Mock token and mock event injection
Notion sync	Stub	Mock token and mock event injection
Shortcut: start dictation	Implemented	Strongest App Intent path
Shortcut: log thought	Partial/risky	Depends on pipeline boot
Siri conversational intent	Stub	Dialog only
Import documents/OCR/audio	Partial/risky	Depends on pipeline boot
Habit capture	Partial/risky	Depends on pipeline boot
Legacy export/management	Partial/risky	Mostly scaffolded
Daily background synthesis	Partial	Registered, not proven active
Cross-device parity	Not achieved	iPhone/iPad only, Mac absent
Full local deterministic API system	Not achieved	Vision ahead of reality

5. Real Data Flow

5.1 Strongest Working Flow

```text

User voice/text on Dashboard

BehaviourIntelligenceLayer

PhiEngine analysis

InstantProcessor

MemoryEngine

SwiftData

Dashboard/Timeline/Knowledge Map visibility

```

5.2 Secondary Event Queue Flow

```text

Capture/import/shortcut input

IntelligencePipeline.enqueue

AevumEvent persisted

EventQueueActor processes event

validation/compression/merge

MemoryEntry updates

```

Risk: not baseline-safe because the pipeline boot binding is not in the normal startup path.

5.3 Local API Flow

```text

Client -> POST /aevum -> prompt payload

local auth header check

PhiEngine.extractConcepts

JSON response text

```

This is inference-serving, not system-of-record CRUD.

6. Existing Integrations

6.1 Real integrations

Apple Speech recognition
AVFoundation recording/UI playback support
EventKit-native calendar context path
Face ID / biometrics
Widgets
App Intents / Shortcuts deep link launch

6.2 Partial integrations

Native calendar sync into intelligence flow
Background tasks
Local model download and local inference runtime

6.3 Stub/mock integrations

Google Calendar
Outlook
Notion
Siri-like core assistant behavior

6.4 Explicit integration truth

Notion today is not an active production integration. It is an OAuth shell plus mock token and mock event injection.

7. Current API Baseline

7.1 What exists

Listener bound to local loopback
Port 8080
POST /aevum
security header X-AEVUM-KEY
request body with prompt
returns synthetic response text

7.2 What does not exist

/thoughts
/tasks
/goals
/insights
/state
/debug/state
/debug/events
full request/response standard described in target architecture

7.3 PM conclusion

The current API should be treated as a narrow developer/local inference endpoint, not the system API contract.

8. Device Behavior Baseline

8.1 iPhone

Primary intended product surface
Best-supported current baseline

8.2 iPad

Supported through shared iOS target
No evidence of full iPad-specific QA baseline

8.3 Mac

No shipped app target
Mac support should be treated as not started for PM planning

9. Automation Baseline

9.1 What is actually automated now

Some queue-triggered local processing
Some app-intent-triggered launch behavior
Widget-triggered deep-link behavior
Background task registration code

9.2 What is not actually established

No proven scheduled operational loop
No robust state validation automation
No device matrix automation
No release-grade observability automation

9.3 PM conclusion

Automation exists as engineering scaffolding, not as a complete operational system.

10. Testing Baseline

10.1 What exists

Package/unit tests in:

- CoreMemory

- DecisionEngine

- IntelligenceEngine

- CloudSyncEngine

- SecurityLayer

10.2 What does not exist

App-level test target baseline
UI test suite
cross-device E2E automation
API + UI + state assertion orchestration

10.3 Test maturity assessment

Layer	Status
---	---
Unit / module tests	Some meaningful coverage
Integration tests	Limited and inconsistent
UI automation	Absent
End-to-end automation	Absent
Release validation system	Absent

11. NFR Baseline

11.1 Local-first

Status: Partial

Reality:

Local storage and local inference are core themes
But there is also model download code and a cloud-consent branch

11.2 Determinism

Status: Partial

Reality:

Event queue and local persistence attempt structure
But multiple mixed write paths and mock/fallback behavior reduce determinism

11.3 Device independence

Status: Not achieved

Reality:

iOS shared only
no Mac

11.4 Security / privacy

Status: Moderate partial implementation

Reality:

biometric controls
local store
local API bound to loopback
but external/mock/cloud branches still present in code

11.5 Observability

Status: Partial

Reality:

telemetry UI and logging exist
no full operational observability baseline

11.6 Testability

Status: Partial

Reality:

package tests exist
full system testability contract does not

12. BRD vs Reality Delta

12.1 What the vision assumes but repo does not yet prove

unified entity model centered on Thought/Goal/Task/State
API as single source of truth
no business logic in UI
same behavior across iPhone/iPad/Mac
all mutations through API
structured testing system with UI + API + state assertions
real external integrations

12.2 What the repo really is

iOS-first local intelligence prototype
mixed business logic placement
mixed storage and orchestration patterns
partial platform scope
scaffolded advanced features
incomplete test and release discipline

13. Scope, Time, Money View

13.1 What is complete enough to preserve

Core iOS shell and navigation
Dashboard interaction pattern
Local SwiftData schema foundation
Voice capture/transcription capability
Widget bundle and deep-link concept
Package modularization structure

13.2 What is dangerous to assume is complete

pipeline-driven ingestion flows
external integrations
scheduled automation
Siri
API architecture
Mac parity
test automation

13.3 Recommended scope baseline

Treat the program today as:

Phase 0: iOS local intelligence prototype

Do not budget or plan it as:

Phase 2/3 multi-device operating system with production integrations

13.4 Cost-control recommendation

Freeze current baseline into documentation first, then choose one of these tracks:

Track A: Stabilize iPhone core only

boot pipeline correctly
rationalize one capture architecture
remove/mock-label non-real integrations
add real app-level tests

Track B: Build API-led architecture

formalize canonical entity model
route mutations consistently
retire mixed paths

Track C: Expand device matrix

only after A or B is stable

Best PM sequence:

Stabilize baseline
Define canonical architecture
Re-scope integrations
Add test system
Then expand surfaces

14. Readiness Assessment

Area	Status
---	---
Product vision readiness	High
Code reality readiness	Medium-low
Architecture coherence	Medium-low
Integration readiness	Low
Test readiness	Low
Release readiness	Low
Documentation readiness after this baseline	High

15. Final PM Conclusion

You currently have a serious prototype, not yet a finished operating system.

The repo contains enough real implementation to justify continued investment, but not enough architectural consistency to scale safely without a reset of ground truth. The correct next management move is not feature expansion. It is architectural reconciliation:

Reality -> documented baseline -> controlled scope -> stabilization -> selective build-out

That is the financially safest path.