implementation-status.mdx

title	Implementation Status Matrix
description	Detailed status of protocol implementations across ObjectStack packages

This document provides a comprehensive overview of which protocols from @objectstack/spec have been implemented in the ObjectStack packages.

**Last Updated**: July 2026

This matrix is generated from actual codebase analysis and represents the current implementation status.

Status Legend

Symbol	Status	Description
✅	Fully Implemented	Production-ready implementation with all core features
⚠️	Partially Implemented	Basic implementation, missing advanced features
🟡	Partially Delivered	Shipping implementation; full protocol parity still in progress
🚧	In Progress	Currently being developed
📋	Planned	Scheduled for future implementation
❌	Not Implemented	Protocol defined but not yet implemented

---

Core Infrastructure (Kernel)

Runtime & Kernel

Protocol	@objectstack/core	@objectstack/runtime	@objectstack/objectql	Status
Manifest	✅	✅	✅	✅ Full
Context	✅	✅	✅	✅ Full
Plugin	✅	✅	❌	✅ Full
Plugin Lifecycle	✅	❌	❌	✅ Full
Plugin Capability	✅	❌	❌	✅ Full
Service Registry	✅	❌	❌	✅ Full
Startup Orchestrator	✅	❌	❌	✅ Full
Events	✅	❌	❌	✅ Full

Notes:

• Core package provides complete microkernel implementation
• Plugin system supports the init/start/destroy lifecycle, dependency resolution, and service injection — the onInstall/onEnable-style hook family was retired in v17 as never-implemented (#4212)
• Event bus enables inter-plugin communication; IPluginLifecycleEvents registers the 14 lifecycle events that actually fire, and LifecycleEventName soft-types hook/trigger (#4241)
• ObjectQL serves as the example kernel — a reference implementation that will be modularized into plugins

Data Infrastructure

Protocol	@objectstack/objectql	@objectstack/runtime	@objectstack/driver-memory	Status
Driver	✅	✅	⚠️	✅ Interface
Datasource	✅	✅	❌	✅ Full
Data Engine	✅	❌	❌	✅ Full
Query	✅	⚠️	⚠️	⚠️ Partial
Filter	✅	⚠️	⚠️	⚠️ Partial

Notes:

• ObjectQL implements complete IDataEngine interface
• Memory driver is the reference implementation: filters, sorting, pagination, aggregations, snapshot transactions, streaming and syncSchema() are on; joins, window functions, subqueries, full-text and vector search are off (InMemoryDriver.supports)
• Advanced query features (joins, window functions, subqueries) require production drivers
• Memory driver supports aggregations (groupBy, count, sum, avg, min, max)

Metadata Framework

**Runtime Boundary** — runtime metadata is file/artifact-backed and read-only at boot. Database-backed metadata persistence exists for explicitly configured control-plane services, not as an automatic runtime project-DB bridge.

• Metadata API (list types, list items, get item) is fully functional
• Metadata is loaded from config files or dist/objectstack.json at startup and held in memory
• MetadataPlugin auto-provisions the sys_metadata / sys_metadata_history storage objects (plus the ADR-0067 commit log and the metadata audit trail) by default, so PUT /api/v1/meta/{type}/{name} always has somewhere to write. Per-project (cloud) kernels opt out with registerSystemObjects: false, because there the control plane owns those tables
• MetadataPlugin does not auto-bridge ObjectQL to a DatabaseLoader — there is no automatic runtime project-DB bridge, and nothing in the packages calls the bridge during boot. Database-backed metadata is an explicit MetadataManager opt-in (setDataEngine() / setDatabaseDriver(), or a datasource + driver pair on the manager config), and even then it is control-plane only: both methods return early whenever an environmentId is supplied, so a per-project kernel never gets a database-backed metadata loader
• The artifact source is artifactSource: { mode: 'local-file', path } — a compiled artifact read from a filesystem path or fetched from an http(s) URL (the control plane's public /pub/v1/environments/:id/artifact[?commit=…] route serves exactly such URLs), honored by all three bootstrap modes (eager / lazy / artifact-only). A second artifact-api mode (a Bearer-authenticated control-plane pull) this page once called "Future / reserved" was removed while resolving #4246: it had zero consumers in any repo — the cloud runtime uses its own ArtifactApiClient, and package installs into a running OSS instance go through @objectstack/cloud-connection — and a still-configured artifact-api source now fails loudly at start() instead of lingering half-declared
• Future: durable local artifact cache — remote artifact URLs re-fetch on every boot

System Services

Protocol	Implementation Package	Status	Notes
Logging	@objectstack/core	✅	Cross-platform logger (browser + server)
API Registry	@objectstack/core	✅	Central endpoint registry
Metrics	@objectstack/observability	✅	Metrics exporters shipped (metrics-exporters.ts)
Tracing	@objectstack/observability	⚠️	Error/exporter pipeline shipped (error-exporters.ts); full distributed tracing in progress
Audit	@objectstack/plugin-audit	✅	Audit writers + audit objects shipped
Job	@objectstack/service-job	✅	Job service with cron/db/interval adapters
Cache	@objectstack/service-cache	✅	ICacheService with in-memory and Redis adapters (cache-service-plugin.ts); HTTP caching ships separately in @objectstack/rest
Translation	@objectstack/service-i18n	✅	i18n/translation service with file adapter
Feature Flags	❌	📋	Planned
Encryption	@objectstack/service-settings	⚠️	ICryptoProvider seam with a local AES-256-GCM provider (local-crypto-provider.ts); secret fields are encrypted at rest into sys_secret (objectql/secret-fields.ts). Managed KMS/Vault providers not shipped
Compliance	❌	📋	Planned
Masking	❌	📋	Planned
Notification	@objectstack/service-messaging	🟡	Framework pipeline shipped; objectui bell cut-over remains
Change Management	❌	📋	Planned
Collaboration	❌	📋	Planned

---

Data Layer (ObjectQL)

Core Data Modeling

Protocol	@objectstack/spec	@objectstack/objectql	@objectstack/client	Status
Field	✅	✅	✅	✅ Full
Object	✅	✅	✅	✅ Full
Validation	✅	⚠️	❌	⚠️ Partial
Hook	✅	✅	❌	✅ Full
Dataset	✅	❌	✅	✅ @objectstack/service-analytics
Mapping	✅	❌	❌	❌ Not Impl
Document	✅	❌	❌	❌ Not Impl
External Lookup	❌	❌	❌	❌ Retired — data/external-lookup.zod.ts was retired outright under ADR-0049 (route 3, D3 external-lookup-message-queue-families-retired, #8075)

Field Type Support:

Field Type	Implementation	Notes
text, textarea, email, url, phone	✅	Full support
number, currency, percent	✅	Full support
boolean, toggle	✅	Full support (there is no checkbox type — a checkbox group is checkboxes)
date, datetime, time	✅	Full support
select, multiselect	✅	Full support
lookup, master_detail	✅	Full support in spec, partial in memory driver
formula	✅	CEL-backed formula fields are implemented
summary	✅	Server-side rollups for count/sum/min/max/avg on child records
json, tags	✅	Full support (there is no array type — use json, tags, or the repeater embedded type)
file, image	✅	File-class fields (image/file/avatar/video/audio) hold an opaque sys_file id; ownership + release are tracked by @objectstack/service-storage

Query Engine

Protocol	@objectstack/objectql	@objectstack/client	@objectstack/driver-memory	Status
Query AST	✅	✅	⚠️	✅ Full
Query Builder	❌	✅	❌	✅ Client
Filter Operators	✅	✅	⚠️	⚠️ Partial
Aggregations	✅	✅	✅	✅ Full
Joins	✅	✅	❌	⚠️ Driver-dependent
Sorting	✅	✅	✅	✅ Full
Pagination	✅	✅	✅	✅ Full
Window Functions	✅	❌	❌	❌ Spec only
Subqueries	✅	❌	❌	❌ Spec only

Notes:

• Full query protocol is defined and implemented in ObjectQL engine
• Actual query capability depends on driver implementation
• Memory driver covers filters, sorting, pagination and aggregations; joins, window functions and subqueries are off
• Client SDK provides query builder utilities (QueryBuilder / FilterBuilder, createQuery / createFilter)

---

API Layer (Transport)

HTTP & REST

Protocol	@objectstack/rest	@objectstack/runtime	@objectstack/plugin-hono-server	@objectstack/client	Status
REST Server	✅	✅ (re-export)	✅	❌	✅ Full
HTTP Server	❌	✅	✅	❌	✅ Full
Endpoint	✅	❌	✅	❌	✅ Full
Router	✅	✅	✅	❌	✅ Full
Discovery	✅	✅	✅	✅	✅ Full
Contract	✅	✅	❌	❌	⚠️ Partial
Protocol	❌	✅	❌	✅	✅ Full
Errors	✅	✅	✅	✅	✅ Full
HTTP Cache	✅	✅	✅	✅	✅ Full
Batch	✅	✅	✅	✅	✅ Full

The data (/api/v1/data), metadata (/api/v1/meta), discovery (/api/v1/discovery), and batch endpoints are implemented in @objectstack/rest (rest-server.ts — registerDiscoveryEndpoints); @objectstack/runtime re-exports RestServer from that package and provides the underlying HTTP server/dispatcher.

REST Endpoints Implemented:

Endpoint Pattern	Method	Purpose	Status
/api/v1	GET	API discovery (alias; the SDK connects via /api/v1/discovery)	✅
/api/v1/meta	GET	List metadata types	✅
/api/v1/meta/{type}	GET	List items of type	✅
/api/v1/meta/{type}/{name}	GET	Get specific metadata item	✅
/api/v1/data/{object}	GET	List records	✅
/api/v1/data/{object}/{id}	GET	Get single record	✅
/api/v1/data/{object}	POST	Create record	✅
/api/v1/data/{object}/{id}	PATCH	Update record	✅
/api/v1/data/{object}/{id}	DELETE	Delete record	✅
/api/v1/data/{object}/createMany	POST	Batch create	✅
/api/v1/data/{object}/updateMany	POST	Batch update	✅
/api/v1/data/{object}/deleteMany	POST	Batch delete	✅
/api/v1/data/{object}/{id}/clone	POST	Clone a record (gated by enable.clone)	✅
/api/v1/data/{object}/batch	POST	Atomic batch operations	✅
/api/v1/batch	POST	Cross-object atomic batch (parent + children in one transaction, $ref)	✅

Every route carries the /api/v1 prefix. When project scoping is enabled each row is additionally mirrored under /api/v1/environments/{environmentId}. The full audited route list lives in packages/rest/src/rest-route-ledger.ts.

Advanced Protocols

Protocol	Implementation	Status	Notes
Analytics	✅	✅	ObjectQL aggregation plus @objectstack/service-analytics dataset execution; analytics read scope auto-bridges to security.getReadFilter for RLS-aware dashboards/reports
OData	❌	📋	Protocol defined, not implemented
Realtime	@objectstack/service-realtime	⚠️	Realtime service shipped, but only the process-local 'memory' adapter (in-memory-realtime-adapter.ts); a Redis-backed HA adapter is a post-GA fast-follow
WebSocket	❌	📋	Protocol defined (spec/api/websocket.zod.ts); no WebSocket transport ships in any package — the realtime service is in-process pub/sub, not a socket transport

---

UI Layer (ObjectUI)

View System

Protocol	@objectstack/spec	Implementation	Status
View	✅	🟡	🟡 Studio/ObjectUI renders authored metadata surfaces; general-purpose renderer coverage is still incomplete
ListView	✅	🟡	🟡 ObjectUI grid/list surfaces support per-view persistence, filters, row actions, density, galleries, and permission-aware affordances; full protocol parity is ongoing
FormView	✅	🟡	🟡 ObjectUI forms support live field rules (visibleWhen / readonlyWhen / requiredWhen), inline-grid row rules, and server-aligned required enforcement
Page	✅	🟡	🟡 Record-page authoring, page create flows, block canvas editing, slotted record pages, and selected page blocks are implemented in ObjectUI; full component catalogue remains in progress
App	✅	🟡	🟡 Navigation metadata is consumed by the console/app shell; full renderer parity remains in progress
Dashboard	✅	🟡	🟡 ObjectUI renders metric/chart/list/pivot/funnel/table widgets, drill-downs (group → records → record chain), type-aware cells, and dataset-bound widgets; Studio can author per-widget dataset bindings (dataset / dimensions / values)
Report	✅	🟡	🟡 ObjectUI renders spec-native tabular/summary/matrix/joined reports, chart/KPI blocks, drill-downs, and dataset-bound reports
Action	✅	🟡	🟡 ObjectUI supports row/global/header actions, action modal transport, parameter collection, visibility CEL, and nested action runners
Component	✅	🟡	🟡 Selected page/record components render in ObjectUI (record:alert, related lists, highlights, page blocks); catalogue parity remains in progress
Theme	✅	❌	❌ Spec only
Widget	✅	🟡	🟡 Dashboard/report/list/form widgets render in ObjectUI; custom widget manifest/runtime parity remains in progress
Chart	✅	🟡	🟡 Recharts-backed dashboard/report charts cover bar/line/pie/area/scatter/funnel/gauge/treemap/sankey with formatting and field-coverage guards

Notes:

• All UI protocols are fully defined in spec
• Metadata API can retrieve UI definitions (views, apps, pages, dashboards, reports, actions)
• Active Studio/ObjectUI source lives in the sibling ../objectui repo and is bundled into packages/console via the objectui refresh workflow
• Metadata-admin curated forms now merge server-only fields back into the save payload, so a Studio form that exposes only part of a metadata type should not strip newer protocol properties
• The 2026-05-08 → 2026-06-08 ObjectUI scan covered 910 non-merge frontend commits. The largest functional clusters were metadata-admin/Studio, master-detail forms, reports/dashboards, record detail/related lists, action transport, flow designer, developer/API pages, AI draft publishing, and i18n.
• React SDK provides data hooks; the cross-surface renderer is still being completed in ObjectUI rather than in this backend repo

---

Automation Layer

**Plugin-Provided Service** — The kernel does NOT include an automation engine. Flow, workflow, and approval services are provided by plugins — the flow engine ships in `@objectstack/service-automation`, with approval nodes in `@objectstack/plugin-approvals`.

Protocol	@objectstack/spec	Kernel	Plugin Required	Status
Flow	✅	❌	✅	✅ @objectstack/service-automation
Workflow	✅	❌	✅	✅ @objectstack/service-automation
Approval	✅	❌	✅	✅ @objectstack/plugin-approvals
Webhook	✅	❌	✅	✅ @objectstack/plugin-webhooks
ETL	✅	❌	✅	📋 Plugin
Sync	✅	❌	✅	📋 Plugin
Trigger Registry	✅	❌	✅	✅ trigger-api / trigger-record-change / trigger-schedule

Notes:

• Hook system is implemented in ObjectQL (beforeFind, afterInsert, etc.) — this is data-layer eventing, not workflow automation
• The flow/workflow engine ships in @objectstack/service-automation (engine.ts, builtin nodes, plugin.ts); approvals, webhooks, and triggers ship as @objectstack/plugin-approvals, @objectstack/plugin-webhooks, @objectstack/trigger-api, @objectstack/trigger-record-change, and @objectstack/trigger-schedule
• ETL and Sync protocols are defined but not yet implemented as plugins
• Discovery API reports automation service as unavailable until a plugin is registered

---

Security Layer

**Plugin-Provided Service** — The kernel does NOT handle authentication or authorization. Security services must be provided by plugins (e.g., `@objectstack/plugin-auth`). The Discovery API reports auth as `unavailable` until a plugin is registered.

Auth Service (plugin-auth)

CoreServiceName names a single auth service — there is no permission entry in that enum. Authentication/identity is what @objectstack/plugin-auth registers under that name. Authorization is registered outside CoreServiceName: @objectstack/plugin-security registers security (plus security.permissions, security.rls, security.fieldMasker) and @objectstack/plugin-sharing registers sharing, sharingRules, and shareLinks.

Protocol	Area	@objectstack/spec	Kernel	Plugin Required	Status
Identity	Authentication	✅	❌	✅	✅ plugin-auth (better-auth)
Auth Config	Authentication	✅	❌	✅	✅ plugin-auth
Position	Authentication	✅	❌	✅	✅ plugin-auth + plugin-security
Organization	Authentication	✅	❌	✅	✅ plugin-auth (tenancy service)
Policy	Authentication	✅	❌	✅	📋 Plugin
SCIM	Authentication	✅	❌	✅	⚠️ plugin-auth, opt-in via OS_SCIM_ENABLED
Permission	Authorization	✅	✅ Phase-1	✅	✅ plugin-security
Sharing	Authorization	✅	❌	✅	✅ plugin-sharing
RLS	Authorization	✅	✅ Phase-1 (tenant + owner)	✅	✅ plugin-security

Notes:

• Security is delivered by three cooperating plugins, not one: plugin-auth (identity, auth + tenancy services), plugin-security (permissions, FLS, RLS, tenant wall), and plugin-sharing (OWD, sharing rules, per-record shares, share links)
• Client SDK supports bearer token header — but token validation requires the auth plugin
• Auth route (/auth/*) only appears in Discovery when the auth plugin is registered
• Fine-grained authorization (RLS, sharing) lives in plugin-security / plugin-sharing, not in the auth plugin. Territory-style access is expressed as an RLS dynamic-membership set (ExecutionContext.rlsMembership, e.g. id in current_user.territory_account_ids) rather than as a dedicated territory module
• Phase-1 RBAC enforcement is live end-to-end: REST → ObjectQL → SecurityPlugin middleware now receives a populated ExecutionContext (userId, tenantId, positions, permissions). Tenant isolation is enforced as a Layer 0 tenant wall (plugin-security/tenant-layer.ts, ADR-0095 D1) that AND-composes organization_id == current_user.organization_id ahead of and independently of business RLS — the earlier wildcard tenant_isolation RLS policy on member_default was retired (an OR-merged business policy could widen it). The default member_default set still ships per-object overrides sys_organization_self (id == current_user.organization_id) and sys_user_self (id == current_user.id) for the global tables that lack an organization_id column. The earlier tenantField indirection (RLS expressions written against an abstract tenant_id column then rewritten to the configured physical column at compile time) was removed — the placeholder, the column name, and RLSUserContext.organization_id are now the same name end-to-end. The legacy objectql.registerTenantMiddleware (hardcoded where.tenant_id injection that pre-dated SecurityPlugin) has been removed; SecurityPlugin is the sole authority for tenant isolation. Analytics now uses the same reusable read scope via security.getReadFilter, so dataset-bound dashboards/reports do not bypass RLS. Verified cross-organization isolation on pnpm dev:crm across sys_organization, sys_member, sys_user, sys_user_permission_set, sys_position_permission_set. Anonymous traffic is always denied (ADR-0056 D2). The deployment-wide opt-out is gone: api.requireAuth was retired in @objectstack/spec 17 (#3963) and is now a tombstoned key that fails validation rather than reopening the data plane. The single decision lives in @objectstack/core (security/anonymous-deny.ts, 401 UNAUTHENTICATED), and every surface that legitimately serves a session-less caller derives its own narrow authorization from a declaration instead: control-plane paths via the auth-gate allowlist, public forms via publicFormGrant (ADR-0056 Option A), share links via a capability token validated then read as SYSTEM, book.audience: 'public' reads via the audience gate, and MCP via an OAuth token or API key.
• OWD / sharing-model enforcement is live and proven end-to-end (ADR-0056): private, public_read, public_read_write, and controlled_by_parent are enforced through plugin-sharing + plugin-security and verified by dogfood proofs over the real HTTP stack. object.sharingModel accepts the canonical OWD vocabulary only (private / public_read / public_read_write / controlled_by_parent) — the legacy read / read_write / full aliases were removed from the enum (ADR-0090 D4), and an unset sharingModel on a custom object resolves to private (ADR-0090 D1). RLS owner policies resolve current_user.email in addition to id / organization_id / positions (#2054). Permission sets may declare isDefault: true as the install-time suggestion to bind the set to the built-in everyone position (ADR-0090 D5, superseding the ADR-0056 D7 fallback-profile mechanism). A sharing rule must state its criteria (#3896): all three write paths reject a match-all shape, a stored criteria-less rule matches nothing, and its materialised grants are revoked on the next reconcile.

---

AI Layer

The in-UI AI **runtime** below ships in **ObjectOS**, not in the open-source framework. The agent / skill / tool **schemas** stay open in `@objectstack/spec/ai`; the **open-source framework** exposes AI via [`@objectstack/mcp`](/docs/ai) (BYO-AI). The Implementation / Status columns describe that separate runtime.

Protocol	@objectstack/spec	Implementation	Status
Agent	✅	ObjectOS runtime	✅ Agent runtime
Model Registry	✅	ObjectOS runtime	✅ Model registry
RAG Pipeline	⚠️	@objectstack/service-knowledge	⚠️ Knowledge service + knowledge-memory / knowledge-ragflow / embedder-openai plugins; spec defines the retrieval binding (ai/knowledge-source.zod.ts, ai/knowledge-document.zod.ts), not a pipeline DSL
NLQ	❌	ObjectOS runtime	⚠️ Data-query tools
Conversation	✅	ObjectOS runtime	✅ In-memory + ObjectQL conversation services
Agent Action	✅	ObjectOS runtime	⚠️ Action/data/knowledge tools (tool.zod.ts + action_<name> tools)
Cost	✅	❌	❌ Spec only — usage.zod.ts accounts tokens/per-call cost; no budget enforcement
Predictive	❌	❌	❌ Not defined
Orchestration	❌	ObjectOS runtime	⚠️ Agent tool orchestration
Feedback Loop	❌	ObjectOS runtime	⚠️ Eval harness
DevOps Agent	❌	❌	❌ Not defined

Notes:

• The @objectstack/spec/ai surface is deliberately narrow — Agent, Skill, Tool, Conversation, Model Registry, Embedding, Usage, MCP, plus the knowledge-source / knowledge-document and solution-blueprint schemas. Application-level protocols (DevOps agents, predictive pipelines, AIOps, orchestration plans, NLQ services, RAG-pipeline DSLs, budget enforcement) were removed in v1 and have no schema today — see the scope note in packages/spec/src/ai/index.ts
• The ObjectOS runtime ships agents, model registry, conversation, tools, skills, and an eval harness
• RAG/embedding is provided by @objectstack/service-knowledge plus the knowledge-memory, knowledge-ragflow, and embedder-openai plugins (all open)
• Token/cost accounting has a schema (ai/usage.zod.ts) but no shipping enforcement; the predictive and DevOps-agent protocols are not defined in spec at all

---

Integration Layer

Protocol	@objectstack/spec	Implementation	Status
Connector	✅	connector-rest, connector-openapi, connector-mcp, connector-slack	✅ REST/OpenAPI/MCP/Slack connectors shipped
SaaS Connector	✅	connector-slack	⚠️ Slack connector shipped; broader SaaS catalogue in progress
Database Connector	✅	@objectstack/driver-sql, driver-mongodb	✅ Delivered via the database drivers
File Storage	✅	@objectstack/service-storage	✅ File storage service with local + S3 adapters and storage routes
Message Queue	✅	@objectstack/service-queue	⚠️ Queue service shipped
GitHub Connector	✅	❌	❌ Spec only
Vercel Connector	✅	❌	❌ Spec only

---

QA & Testing

Protocol	@objectstack/spec	@objectstack/core	@objectstack/verify	Status
Testing	✅	✅	✅	✅ Full

Features Implemented:

• TestSuite, TestScenario, TestStep schemas ✅
• HTTP adapter for testing ✅ (packages/core/src/qa/http-adapter.ts)
• QA runner in core ✅ (packages/core/src/qa/runner.ts)
• Conformance/dogfood harnesses in @objectstack/verify and packages/qa (dogfood, downstream-contract, http-conformance) ✅

There is no MSW package in this repo — browser API mocking is a devDependency of the sibling objectui frontend, and @objectstack/driver-memory is what backs those in-browser fixtures.

---

Implementation Roadmap

Phase 1: Core Infrastructure ✅ COMPLETE

• [x] Microkernel & Plugin System
• [x] Logging System
• [x] Service Registry
• [x] Event Bus
• [x] API Registry

Phase 2: Data Layer ✅ COMPLETE

• [x] ObjectQL Engine
• [x] Schema Registry
• [x] Protocol Implementation
• [x] Basic Query Support
• [x] CRUD Operations
• [x] Hook System

Phase 3: API Layer ✅ COMPLETE

• [x] REST Server
• [x] HTTP Server (Hono)
• [x] Endpoint Generation
• [x] Discovery API
• [x] Metadata API
• [x] Batch Operations
• [x] HTTP Caching

Phase 4: Client SDKs ✅ COMPLETE

• [x] TypeScript Client
• [x] React Hooks
• [x] Query Builder
• [x] Error Handling

Phase 5: Developer Tools ✅ COMPLETE

• [x] CLI Tools
• [x] Config Validation
• [x] Development Server
• [x] Metadata Management

Phase 6: Advanced Features 🚧 IN PROGRESS

• [x] Production Database Drivers — @objectstack/driver-sql (PostgreSQL/MySQL dialects), @objectstack/driver-mongodb, and @objectstack/driver-sqlite-wasm ship; additional dialect coverage ongoing
• [ ] OData Support
• [ ] Realtime Subscriptions
• [ ] WebSocket Support

Phase 7: UI Layer 🟡 IN PROGRESS

• [ ] UI Renderer
• [x] Studio metadata-admin engine — generic metadata list/detail/edit surfaces, live preview, draft/publish/rollback, create-mode forms, server-side diagnostics, package scoping, and skew-safe curated inspectors
• [x] Form conditional rules — ObjectUI supports visibleWhen, readonlyWhen, requiredWhen, row-scoped inline-grid rules, and required-on-submit enforcement
• [x] Master-detail forms — inline subforms, spreadsheet-style line items, atomic batch create/edit, lookup auto-fill, line ordering, duplicate/reorder, and subtotal/tax/total stack
• [x] Record detail + related lists — derived related lists, record-page assignment, action slots, system/audit sections, and opt-in reference rail
• [x] Dashboard renderer/editor — widget layout persistence, drill-downs, pivot/funnel/table/list widgets, type-aware cells, and per-widget dataset binding authoring (dataset, dimensions, values)
• [x] Report renderer/editor — spec-native summary/matrix/joined reports, chart/KPI blocks, drill-downs, dataset-bound reports, and i18n labels
• [x] Flow/page designers — typed flow node config panels, simulator/debug runner, page block canvas, slotted record pages, and schema-driven block inspectors
• [x] Action transport — row/global/header actions, modal parameter collection, visible CEL, popup-safe open actions, and nested action runner sharing
• [x] Developer/admin console surfaces — Integrations & APIs, public forms, flow runs, approvals inbox, settings, marketplace/package management, AI draft review/publish
• [ ] List View Renderer full protocol parity
• [ ] Cross-surface UI Renderer full protocol parity
• [ ] Theme Engine

Phase 8: Automation (Plugin) 🟡 IN PROGRESS

• [x] Flow Engine Plugin
• [x] Approval Node Plugin
• [x] Trigger Registry Plugins — @objectstack/trigger-api, @objectstack/trigger-record-change, @objectstack/trigger-schedule (including the time-relative trigger)
• [ ] ETL Pipeline Plugin
• [ ] Sync Plugin

Phase 9: Security (Plugin) 🟡 PHASE-1 LANDED

• [x] Authentication Plugin (@objectstack/plugin-auth, better-auth)
• [x] Authorization Plugin — @objectstack/plugin-security enforces CRUD/FLS/RLS in the ObjectQL middleware chain; REST → ObjectQL now propagates ExecutionContext end-to-end (Phase-1)
• [x] Row-Level Security — tenant isolation is a Layer 0 tenant wall (plugin-security/tenant-layer.ts, ADR-0095 D1) that AND-composes organization_id == current_user.organization_id independently of business RLS (the earlier wildcard tenant_isolation policy on member_default was retired); member_default still applies per-object overrides sys_organization_self / sys_user_self. The earlier tenantField rewrite indirection was removed: RLS column, placeholder, and RLSUserContext.organization_id use the same canonical name end-to-end. Policy enabled: false is enforced at the compiler choke point — a disabled policy no longer contributes its OR-branch grant (#3980) — and the void rowLevelSecurity[].priority key was removed in @objectstack/spec 17.0.0 (#3896 security audit)
• [x] Analytics RLS bridge — @objectstack/service-analytics auto-bridges to security.getReadFilter(object, context) and fails closed when read-scope resolution cannot be safely applied
• [x] Multi-tenancy — verified cross-organization isolation on pnpm dev:crm (Alice@OrgAlpha vs. Bob@OrgBeta only see their own records across sys_organization, sys_member, sys_user, and sys_*_permission_set link tables)
• [x] Legacy objectql.registerTenantMiddleware removed — SecurityPlugin is now the sole tenant-isolation authority
• [x] Organization-Wide Defaults / sharing model — private, public_read, public_read_write, and controlled_by_parent enforced via plugin-sharing + plugin-security, proven by dogfood over the real HTTP stack (ADR-0056). Canonical vocabulary only — legacy aliases removed from the enum (ADR-0090 D4); unset custom-object OWD resolves to private (ADR-0090 D1)
• [x] Sharing Rule evaluator — criteria rules re-evaluated on afterInsert / afterUpdate (plugin-sharing/rule-hooks.ts); every authorable recipient maps 1:1 onto an enforced expandRecipient branch (plugin-sharing/sharing-rule-service.ts) — user, team, position, business_unit, and unit_and_subordinates (business-unit-subtree widening, ADR-0057 D5 / ADR-0090 D3). Under ADR-0078 enforce-or-remove, criteria is now the only rule type (owner-type rules were removed from the authoring surface because the static materialiser cannot track live membership), the group recipient was renamed to team, guest was removed, and queue stays reserved in the runtime contract but deliberately non-authorable
• [x] Everyone-baseline suggestion — a permission set may set isDefault: true as the install-time suggestion to bind it to the built-in everyone position; resolved per-request as an additive baseline, no fallback cliff (ADR-0090 D5)
• [x] Default-deny for anonymous traffic — the global default-deny landed (ADR-0056 D2) and the api.requireAuth opt-out was then removed in @objectstack/spec 17 (#3963): the key is tombstoned and rejected at parse time, the deny decision is centralised in @objectstack/core security/anonymous-deny.ts, and public forms self-authorize via publicFormGrant (Option A)
• [ ] Studio RLS visual editor
• [ ] Per-user×org permission cache
• [ ] Audit UI / denied-access logging

Phase 10: AI Integration 🟡 IN PROGRESS

• [x] RAG Pipeline — @objectstack/service-knowledge plus the knowledge-memory, knowledge-ragflow, and embedder-openai plugins ship in this repo
• [x] MCP surface — @objectstack/mcp exposes the platform to any BYO-AI client
• [ ] Agent Framework (ObjectOS runtime; not in the open-source framework)
• [ ] NLQ Engine (ObjectOS runtime)
• [ ] Model Registry (ObjectOS runtime)

---

Summary Statistics

Overall Implementation Status

Category	Total Protocols	Status
Data	16	Core modeling, hooks, and query engine fully implemented; document/mapping still pending; external-lookup retired outright under ADR-0049 (route 3, #8075)
UI	10	Studio/ObjectUI render most authored surfaces (🟡); full cross-surface renderer parity in progress
API	14	REST/HTTP/discovery/batch fully implemented; OData and the WebSocket transport pending; GraphQL removed from the plan
System	39	Logging, audit, job, translation, metrics, cache, notification implemented; encryption partial (local crypto provider); several governance services pending
Auth (plugin)	10	Identity/organizations live (plugin-auth), permission + RLS live (plugin-security), OWD + sharing rules live (plugin-sharing); SCIM is opt-in
Automation (plugin)	7	Flow, workflow, approval, webhook, and triggers implemented; ETL/Sync pending
AI	12	Agents, model registry, conversation, tools, RAG implemented (ObjectOS runtime + open knowledge plugins); cost accounting has a schema but no enforcement, and the predictive / DevOps-agent protocols are not defined in spec
Integration	7	REST/OpenAPI/MCP/Slack connectors, file storage, and queue implemented; GitHub/Vercel connectors pending
QA	1	Fully implemented

Implementation Coverage

Implementation spans every layer of the platform. Core infrastructure, data modeling, the REST API, client SDKs, security (Phase-1), automation, AI, and integration all have shipping implementations. Remaining gaps are concentrated in specific protocols (OData, cross-surface UI renderer parity, ETL/Sync, the mapping/document data protocols, and a handful of governance and AI-cost services) rather than entire layers; the external-lookup data protocol was retired outright rather than left pending (ADR-0049 route 3, #8075). Refer to the per-layer tables above for protocol-level status.

Core Functionality Status

Feature Area	Status	Production Ready
Kernel & Plugins	✅	Yes
Data Modeling	✅	Yes
Query Engine	⚠️	Partial (depends on driver)
REST API	✅	Yes
Client SDKs	✅	Yes
Metadata System	⚠️	Partial (sys_metadata persistence via MetadataPlugin; without it the kernel's in-memory fallback fills the slot and discovery reports it degraded)
HTTP Caching	✅	Yes
Testing Tools	✅	Yes
UI Rendering	🟡	Partial (Studio/ObjectUI render authored surfaces; cross-surface renderer parity in progress)
Workflows	✅	Yes (plugin: service-automation)
Security	⚠️	Partial (Phase-1 RBAC/FLS/RLS via plugin-security; OWD + sharing rules via plugin-sharing; identity via plugin-auth)
AI Features	⚠️	Partial (ObjectOS runtime + open knowledge plugins)

---

Package Feature Matrix

Feature	spec	core	objectql	runtime	client	client-react	cli	metadata	hono	memory
Protocol Definitions	✅	❌	❌	❌	❌	❌	❌	❌	❌	❌
Microkernel	❌	✅	❌	❌	❌	❌	❌	❌	❌	❌
Plugin System	❌	✅	❌	✅	❌	❌	❌	❌	❌	❌
Service Registry	❌	✅	❌	❌	❌	❌	❌	❌	❌	❌
Event Bus	❌	✅	❌	❌	❌	❌	❌	❌	❌	❌
Logging	❌	✅	❌	❌	❌	❌	❌	❌	❌	❌
Schema Registry	❌	❌	✅	❌	❌	❌	❌	❌	❌	❌
ObjectQL Engine	❌	❌	✅	❌	❌	❌	❌	❌	❌	❌
Protocol Implementation	❌	❌	✅	❌	❌	❌	❌	❌	❌	❌
REST Server	❌	❌	❌	✅	❌	❌	❌	❌	❌	❌
Endpoint Generation	❌	❌	❌	✅	❌	❌	❌	❌	❌	❌
HTTP Server	❌	❌	❌	✅	❌	❌	❌	❌	✅	❌
Client SDK	❌	❌	❌	❌	✅	❌	❌	❌	❌	❌
Query Builder	❌	❌	❌	❌	✅	❌	❌	❌	❌	❌
React Hooks	❌	❌	❌	❌	❌	✅	❌	❌	❌	❌
CLI Commands	❌	❌	❌	❌	❌	❌	✅	❌	❌	❌
Config Validation	❌	❌	❌	❌	❌	❌	✅	❌	❌	❌
Metadata Loading	❌	❌	❌	❌	❌	❌	❌	✅	❌	❌
File Watching	❌	❌	❌	❌	❌	❌	❌	✅	❌	❌
Database Driver	❌	❌	❌	❌	❌	❌	❌	❌	❌	⚠️

The REST server, endpoint generation, and data/meta/batch endpoints are implemented in the @objectstack/rest package (not shown as a column above); @objectstack/runtime re-exports RestServer from it.

---

Next Steps