Skip to content
ContractSpec
Start here

Capabilities and system areas

Understand the pieces before choosing a package.

Each area has an orientation guide, practical entry points and a complete package list.

Trace a product route to its module owner

Assemble reusable modules, runtimes and integrations into an actual product with owned routes, authority and operational dependencies.

  • What belongs in a module, bundle and app?
  • How does LSSM OS compose the reusable pieces?
  • Where is the product’s installed capability and journey coverage recorded?
10 packages

Inspect quote-to-cash state

Model commercial lifecycles, exact money and reviewable financial handoffs with provider and country boundaries kept explicit.

  • Where do country-neutral billing contracts stop?
  • How do billing facts become a FinanceOS handoff?
  • Which operations require a concrete adapter and approval?
27 packages

Embed a communication surface

Compose messaging, delivery, channels and notifications around scoped journals and current send authority.

  • Which layer is the protocol, runtime, reusable UI or host?
  • What changes between a message draft and an authorized send?
  • How do provider events become durable communication records?
36 packages

Trace an operating proposal into Work

Connect operating goals, shared work, planning, meetings and support through their canonical domain boundaries.

  • Which package owns tasks and project state?
  • How do CompanyOS projections use shared work?
  • How can support and meeting workflows hand off work without copying another domain?
30 packages

Inspect a generated content draft

Move from source-grounded drafts and optimization reports to reviewed publishing, measurement and commercial lifecycle evidence.

  • Which package drafts content and which can publish it?
  • What invalidates an editorial approval?
  • How do creator earnings and growth rewards preserve evidence?

Trace a desired-state plan

Connect source intent, governed plans and provider execution through exact revisions, receipts and recoverable operational state.

  • What does LSSM OS planning own and what does a provider execute?
  • How are source changes admitted before mutation?
  • Which evidence supports deployment or recovery?
10 packages

Compose a form respondent and management surface

Collect structured input, present records, and plan governed import/export flows using shared models and explicit host ports.

  • Which package owns form lifecycle versus form UI?
  • How do immutable form publications relate to responses?
  • Where can I preview a mapping before applying it?
10 packages

Inspect a digest-bound permit

Resolve policy and review decisions into explicit evidence before consequential work is allowed to proceed.

  • What is a decision trace versus an execution permit?
  • How does Connect bind a decision to the exact work?
  • Where do human review and obligations enter the flow?
6 packages

Trace authenticated subject construction

Carry trusted actor and tenant context through product requests, agent actions and shared runtime projections.

  • Which layer authenticates a person and which projects authority?
  • How does subject context reach server-rendered UI?
  • How do provisioning and delegation remain scoped?
60 packages

Find a capability-level provider contract

Choose concrete external capabilities through provider-neutral contracts, explicit connections and observable runtime bindings.

  • Where is the portable interface for a provider capability?
  • How do connection credentials differ from runtime mode?
  • What makes a provider supported for a particular operation?
38 packages

Follow source qualification and revalidation

Manage discovered sources, evidence-backed facts and candidate-authorized application work through explicit lifecycle boundaries.

  • How do discovered sources become eligible facts?
  • What makes a research result traceable?
  • Where does a candidate authorize an application effect?
3 packages

Trace ingestion through retrieval

Turn authorized source material into retrievable, cited context while preserving its source, scope and freshness.

  • What is a knowledge space versus a vector-store collection?
  • How does ingestion become usable evidence?
  • Which provider and access boundaries does a knowledge host supply?

Instrument one request path

Follow behavior across boundaries and distinguish declared support from evidence that a selected composition works.

  • Where do signal declarations differ from telemetry emission?
  • How does trace context cross asynchronous boundaries?
  • Which test proves the behavior I am claiming?

Trace a personal command and receipt

Compose subject-controlled personal workflows and learning experiences with explicit consent, replay and progress semantics.

  • How is personal authority bound to a command?
  • Which runtime owns learning progress or gamification?
  • How are private records kept separate from organization views?
9 packages

Trace an operation from request to handler

Connect declared operations to supplied handlers, client state and the transport your application actually runs.

  • What belongs in the portable runtime kernel?
  • Which adapter matches my REST, GraphQL or MCP host?
  • Where are approvals and authenticated context enforced?
36 packages

Find the owner of a command

Navigate the command host, source analysis, documentation generators and native agent-pack delivery used to work on ContractSpec projects.

  • Which package owns a CLI command?
  • How are optional command packs discovered?
  • Where do docs, skills and editor integrations get their context?
26 packages

Choose a rendering layer

Compose contract-driven views, role-aware operating surfaces and shared design primitives for web and native hosts.

  • Do I need a presentation renderer, a design component or a complete surface?
  • How are resolved preferences passed into UI?
  • Where do role-aware actions and feature hubs belong?
12 packages

Compose an existing workflow

Compose repeatable work with explicit state, persistence, branching and operation-execution responsibilities.

  • Do I need workflow composition, a scheduler or a product module?
  • How are extensions applied without breaking the graph?
  • Where are state and effect execution supplied?