Skip to content

ROADMAP.md

Latest commit

 

History

History
285 lines (218 loc) · 14.9 KB

ROADMAP.md

File metadata and controls

285 lines (218 loc) · 14.9 KB
Raw

Roadmap

M0: Contract And Verification

Goal: prove that AIBA can describe and deterministically verify one capability.

  • Record product vision and architecture decisions.
  • Establish TypeScript monorepo and quality gates.
  • Add Capability Contract v0 schemas.
  • Implement project initialization and inspection.
  • Implement receipt and evidence verification.
  • Add the review-access capability pack.
  • Validate passing and failing fixtures through the CLI.

M1: Agent-Assisted Installation

Goal: let Codex and Claude Code install review-access into an existing TypeScript project.

  • Define the Agent operation protocol.
  • Implement aiba add review-access preparation and finalization.
  • Add a portable Codex and Claude Code skill adapter.
  • Create a native WeChat Mini Program reference adapter.
  • Add black-box HTTP and native client contract tests.

M2: Customization-Aware Upgrade

Goal: upgrade a deeply customized capability from v1 to v2 safely.

  • Record generated ancestry and semantic ownership.
  • Define migration operations and conflict classes.
  • Implement aiba diff and aiba upgrade.
  • Demonstrate v1-to-v2 review-access migration on clean and customized fixtures.

M3: Core Capability Set

  • Identity contract and reference adapter.
  • Users lifecycle contract and reference adapter.
  • Authorization contract and reference adapter.
  • Audit contract and reference adapter.
  • Notification contract and reference adapter.
  • Shared security interface schemas and cross-capability attack tests.

M4: Ecosystem And Control Layer

  • Signed capability bundles, publisher keys, and local trust policy.
  • Signed registry indexes, local resolution, expiry, and anti-rollback state.
  • Authenticated private registry transport and verified local caching.
  • Team policy, signed approvals, separation of duties, and upgrade governance.
  • Define the open Core and hosted-control boundary.
  • Build hosted key custody, signed review workflows, and enterprise integrations.

M5: Self-Hosted Registry MVP

  • Add verified, atomic bundle import for registry operators.
  • Add an authenticated read-only v0 reference server.
  • Support direct TLS and explicit localhost HTTP development mode.
  • Validate the full registry before accepting traffic.
  • Exercise publish, serve, fetch, rollback, and attack paths end to end.
  • Document self-hosting and first-release operation.

M6: Installable Distribution

  • Define the four-package npm topology and lockstep SemVer policy.
  • Package official capabilities with the installed CLI.
  • Define protocol compatibility and deprecation policy.
  • Add the generated-output exception and Apache-2.0 protocol boundary.
  • Build deterministic tarballs and a clean external-consumer trial.
  • Add a protected tag-driven npm provenance and GitHub Release workflow.
  • Publish and install the first public npm release after explicit approval.
  • Configure npm Trusted Publishing for unattended provenance releases.
  • Complete qualified legal review before broad public launch.

M7: General Capability System

Goal: prove that AIBA delivers verifiable software capabilities beyond the initial identity and security foundation.

  • Define the five-layer capability taxonomy and compatibility rules.
  • Add a backward-compatible capability-layer field to the public protocol.
  • Classify every official capability and validate catalog consistency.
  • Deliver file-assets as the first non-identity application capability.
  • Add secure reference behavior and adversarial conformance tests for files.
  • Deliver import-export as the first reusable business capability.
  • Validate project-specific domains against shared capability contracts.
  • Deliver wechat-miniprogram-auth as the first platform integration.
  • Define hash-bound solution composition without allowing invariant weakening.
  • Compose and verify an exact dependency-ordered application Solution.
  • Add standalone publisher signatures before enabling third-party or non-npm Solution distribution; this does not block the current official channel.
  • Validate selected capabilities in TypeScript API, web admin, and native WeChat Mini Program projects without imposing a shared UI framework.

M7 is complete when at least one capability from each of the first four layers has passed the full install, verify, provenance, distribution, and upgrade lifecycle, and one application Solution composes them without bypassing individual verification.

M8: Beta Adoption

Goal: let a developer discover, evaluate, install, and verify AIBA in a real project without reading repository internals.

  • Add verified aiba list discovery across all capability layers and Solutions.
  • Add aiba show for exact dependencies, interfaces, invariants, and composition.
  • Add a guided Solution installation workflow that preserves per-capability plans.
  • Run an invited human beta in a real Mini Program repository.
  • Record setup time, verification failures, Agent corrections, and upgrade feedback.

M8 is complete when an invited developer can select a Solution from the CLI, adapt it through an Agent, pass independent verification, and repeat the process from documented steps without maintainer intervention.

M9: Trusted Behavioral Proofs

Goal: bind an externally executed test result to the exact project, capability, runner identity, challenge, and source snapshot without executing pack-provided commands in Core.

  • Define challenge, signed proof, runner trust, and revocation protocols.
  • Add prepare, attest, and verify behavior-proof commands.
  • Reject replayed, expired, stale, unsigned, or untrusted proofs.

M10: Resumable Agent Orchestration

  • Persist inspectable Solution workflow state without duplicating Core truth.
  • Add status, continue, and doctor commands with JSON output.
  • Preserve one-capability-per-step execution and safe interruption recovery.

M11: Agent Adapter Protocol

  • Publish a machine-readable Agent capability and error envelope.
  • Add protocol negotiation and consistent Codex/Claude adapter guidance.
  • Test every advertised command and structured failure contract.

M12: Capability Authoring SDK

  • Scaffold capabilities and Solutions from safe built-in templates.
  • Add authoring lint and test-pack quality gates.
  • Check identifiers, schemas, dependency closure, recipes, and security tests.

M13: Signed Solution Distribution

  • Sign exact Solution files with Ed25519 publisher identities.
  • Enforce publisher allowlists, key revocation, expiry, and anti-rollback state.
  • Keep official npm provenance valid while enabling independent channels.

M14: Production Registry Operations

  • Add authenticated health, readiness, and Prometheus metrics endpoints.
  • Add verified backup, restore, retention, and dry-run garbage collection.
  • Ship a hardened container image and deployment example.

M15: Beta-Ready Developer Experience

  • Provide a ten-minute Quick Start and standalone example path.
  • Add stable errors, complete JSON output, shell completion, and diagnostics.
  • Validate Linux, macOS, and Windows behavior in CI where applicable.

M9-M15 are development-complete when all public protocols have schemas, all commands ship in npm tarballs, adversarial tests pass in CI, and the documented clean-project path is reproducible. Hosted multi-tenancy, billing, production key custody, qualified legal review, and invited human beta remain external launch gates rather than claims made by the open-source implementation.

M16: Common Application Protocol

Goal: standardize repeated application semantics before they fragment across capability packs.

  • Define bounded resource query, filter, sort, cursor, and page contracts.
  • Define reusable idempotency and optimistic revision fields for mutations.
  • Add strict JSON Schemas, TypeScript bindings, validators, and malformed-input tests.

M17: Reusable Application Operations

Goal: cover operational capabilities repeatedly rebuilt in ordinary Agent- generated applications without imposing a database, queue, provider, or UI.

  • Deliver verification-challenge for single-use email, SMS, and authenticator challenges.
  • Deliver scheduled-jobs with leases, bounded retries, and idempotent execution.
  • Deliver webhooks with trusted destinations, signatures, replay defense, and delivery state.
  • Deliver feature-flags with trusted targeting, deterministic rollout, and revisioned policy.
  • Deliver organization with tenant-derived membership and last-owner protection.
  • Deliver comments-activity with attributable, revisioned, soft-deleted discussion records.
  • Deliver search with bounded queries, authorization-first filtering, and opaque cursors.

M18: Business Workflow Foundation

Goal: provide higher-level application behavior that composes the common protocol and operational capabilities.

  • Deliver reporting with server-owned definitions, authorization, bounded execution, private outputs, and sensitive-field minimization.
  • Deliver workflow-approval with explicit state transitions, separation of duties, optimistic concurrency, and immutable decisions.
  • Upgrade notification with template versions, preferences, durable deduplication, delivery lifecycle, and minimized receipts.
  • Integrate every new pack into discovery, Agent guidance, reference fixtures, deterministic npm tarballs, and smoke tests.
  • Publish the expanded capability model and catalog in bilingual documentation.

M16-M18 are complete when every public interface is schema validated, each capability has a framework-neutral recipe and executable positive and adversarial reference tests, all packs are discoverable from the installed CLI, and pnpm check plus the Linux/macOS/Windows CI matrix pass.

M19: Composition-Ready Application Primitives

Goal: cover recurring product semantics that ordinary Agent-built applications need beyond authentication and CRUD, while keeping rendering, storage, and provider choices project-owned.

  • Deliver i18n with revisioned catalogs, trusted locale resolution, fallback, pluralization, and sanitized interpolation.
  • Deliver data-dict with typed tenant dictionaries, hierarchy, status, revision, and server-side value validation.
  • Deliver form-engine with portable definitions, exact schema revisions, trusted validation, dependency checks, file scoping, and idempotent submission.
  • Deliver inbox with trusted message creation, principal-scoped listing, signed cursors, unread counts, and revisioned state transitions.
  • Deliver tags with normalized tenant-unique names, safe archival, and authorized atomic resource assignments.
  • Integrate all five packs into fixture provenance, Agent guidance, source smoke, deterministic npm tarball checks, and bilingual documentation.
  • Pass the complete local check.
  • Confirm the remote portability workflows after push.

M19 is complete when all 24 official capabilities are dependency ordered and discoverable, the 23-capability reference fixture verifies exact source and test evidence, all five M19 packs score 100 in authoring checks, and the complete local and hosted CI gates pass.

M20: Domain-Neutral Application Blueprints

Goal: let a user describe a project-specific application while AIBA deterministically resolves reusable capabilities and bounded Agent work without turning any example business domain into product infrastructure.

  • Remove project-specific business models from official protocols, packs, Solutions, executable fixtures, and release artifacts.
  • Define strict Blueprint, Application Plan, and Blueprint Upgrade Plan protocols with language-neutral TypeScript bindings.
  • Compile resources, workflows, authorization intent, events, UI intent, evidence, and write scopes into an exact dependency and Agent task graph.
  • Expose aiba create app <id> and read-only aiba plan <app.yaml>.
  • Preserve compatible project-owned customization and require explicit decisions for breaking, security-sensitive, and conflicting upgrades.
  • Exercise a domain-neutral collaboration application and adversarial cases.
  • Confirm the complete hosted portability and mirror workflows after push.

M20 is complete when all three schemas ship in aiba-spec, the installed CLI can scaffold and plan a Blueprint, v1-to-v2 upgrades preserve project-owned customization, unsafe intent is rejected, pnpm check passes, and hosted CI confirms the same result. Business nouns remain project data at every boundary.

M21: Blueprint Lifecycle

Goal: turn Blueprint planning into a durable local workflow without turning plans into generated application code or silently applying upgrades.

  • Persist source-bound Application Plans with explicit safe output paths.
  • Add deterministic aiba app-diff <old.yaml> <new.yaml> with security-aware classifications.
  • Add aiba app-upgrade <old.yaml> <new.yaml> with persisted plans and explicit resolutions.
  • Advertise the workflow through Agent negotiation and shell completion.
  • Exercise the complete lifecycle with domain-neutral fixtures, npm consumers, and adversarial stale/path/resolution cases.

M21 is complete when plans round-trip through Core validation, diffs are stable, upgrades require explicit non-additive decisions, no application code is mutated, and local plus hosted verification passes.

M22: Team and Enterprise Readiness

Goal: make AIBA ready for multi-project teams and self-hosted enterprise deployments, with stronger governance, registry operations, and auditable behavior evidence.

  • Publish a five-step best-practice playbook that walks teams from first Blueprint to production-grade verification and upgrades.
  • Add a reference governance workflow with policy scaffolding, key-rotation guidance, and approval audit reporting commands.
  • Add a private registry onboarding path for multi-repo organizations, including publisher onboarding, index promotion, and anti-rollback state backup procedures.
  • Ship a behavior-proof reference runner integration so teams can bind runtime test results to exact source snapshots and produce audit-ready evidence.
  • Add a Solution packaging guide for internal platforms, so teams can publish their own verified internal foundations the same way AIBA ships secure-workspace.
  • Strengthen inspection and verification reports with stable JSON summaries, diff reports, and machine-readable compliance evidence.
  • Provide hardened self-hosted reference deployment for registry and governance components.

M22 is complete when a team can adopt AIBA across multiple projects, run their own private registry, enforce signed governance policies, produce auditable evidence, and package internal platforms as verified Solutions.