Un sistema conectado, diseñado para evolucionar contigo.

Begin with portable operation, event, capability and feature definitions when authoring a reusable contract.

Use the compatibility distribution to understand existing consumers and forwarding paths in this source snapshot.

Inspect the maintained documentation, review and platform contract families for complete source examples.

Inputs, outputs and outcomes need explicit models before a handler or transport can validate them.

Registries, handlers and adapters turn declarations into an executed request.

Features become useful product capabilities when a host supplies their dependencies.

Use schema models and the existing Zod, JSON Schema, GraphQL and entity surfaces.

Use canonical result and query primitives shared by contracts and adapters.

Use existing utility types for compile-time transformations without confusing them with runtime validation.

A schema becomes meaningful at an operation, event, entity or presentation boundary.

Adapters must preserve the validated input and canonical result semantics.

Forms and import/export workflows consume these shared schema models.

Start with the framework-neutral engine, canonical registries and caller-supplied runtime ports.

Inspect the REST adapter matching your framework and its request/context handling.

Use the existing contract-to-MCP adapter when exposing a selected operation registry to tools.

Locate the React consumer integration for the shared query/cache runtime.

The operation definition fixes the input, outcome and policy the runtime must preserve.

Validation and serialization must match at both sides of the request.

The host constructs trusted request authority.

Required approval evidence belongs in the execution context.

Use presentation transforms, adaptive defaults and bundler helpers shared across renderers.

Use the React rendering and workflow-facing presentation layer.

Inspect surface specs, planners, RoleMorph, feature hubs and React integration.

Use the shared design-system component surface for product UI composition.

Presentation descriptors refer to behavior and data contracts.

A role-aware view must receive trusted actor and policy context.

Tables and forms need schema-aware state and validation.

The host chooses the design pack, route and available capabilities.

Use the canonical caller-port form lifecycle, document compiler and validation helpers.

Choose reusable builder, respondent, results and administration composition for the host.

Start with codecs, mapping, plans and preview contracts before binding a transport or store.

Form documents and mappings rely on the selected schema model.

Management and response sessions require distinct trusted scopes.

Renderers display the selected form/data-view state.

Concrete stores, delivery and external data sources implement supplied ports.

Start with wire contracts, runtime capabilities and validation vocabulary shared by agent hosts.

Use the canonical runtime, task-tree, context compiler, approval and tool orchestration surfaces.

Locate context-pack/snapshot contracts and in-memory or supplied storage primitives.

Inspect the reusable execution harness and its declared environment boundaries.

Tools and agent lifecycle operations need exact contracts.

Agent principals and delegated subjects must be constructed by a trusted host.

Retrieval supplies evidence that the context compiler can classify and budget.

A plan or model response does not issue its own authority.

Use ingestion, retrieval, query, access and knowledge-runtime composition primitives.

Inspect the concrete embedding provider boundary selected by an ingestion host.

Inspect the concrete vector-store adapter used by indexing and retrieval.

Store the selected pack or snapshot when the caller needs a durable context identity.

Source records, queries and evidence references must keep their declared shapes.

Knowledge selection must use trusted tenant, actor and purpose context.

Retrieved content becomes classified input to a bounded agent context.

Research runtimes supply versioned evidence and suppression policy.

Use the workflow registry, composition/validation and supplied-authority runner surfaces.

Inspect reusable boards, DAG/composer views, instance lifecycle and approval composition.

Inspect the shared job scheduling/execution abstractions used by a host.

Explore the source runtime for living operating procedures and their generation context.

A step refers to a known operation or event, with its declared outcomes.

Branching and planning must preserve the effect authority of each step.

Agents can propose or perform bounded work inside a declared workflow.

Durable workers and execution environments implement operational concerns.

Start with the identity, authentication, federation and account-surface contracts.

Use subject providers, SSR scope and deterministic security/provisioning projections.

Inspect the concrete Better Auth integration used by the selected host.

Locate reusable role and permission composition already used by domain modules.

An operation must describe the authority context its host needs.

Identity is one input to a policy or approval decision.

Role-aware presentation consumes resolved subject and policy state.

Personal data and delegated household actions need subject-specific scope.

Use the existing packet authority and durable, signed decision boundaries.

Use deterministic predicates and decision-graph evaluation/conversion.

Inspect reusable human-review composition around governed work.

Locate review queue, assignment and decision-facing composition.

A decision must use trusted actor, scope and current entitlement.

The proposed action and its required approval must be named precisely.

The selected branch can reference a permitted workflow operation.

Execution verifies the permit against the exact plan and current state.

Inspect the canonical messaging and governance contracts before selecting a channel.

Use journal, projection, delivery and authority logic with supplied persistence/provider ports.

Choose reusable routes, contextual slots and communication UI composition.

Inspect the shared concrete channel integration boundary before selecting Discord, email, Slack, SMS or Telegram.

Membership, tenant scope and principal identity determine permitted communication.

Provider events and message actions need stable semantic contracts.

Conversations can create handoffs, support cases and work proposals.

Channel SDKs, credentials and external delivery live in adapters.

Begin with country-neutral quote-to-cash contracts, lifecycle evidence and operation descriptions.

Use deterministic lifecycle projections, supplied persistence ports and economic-truth helpers.

Inspect exact-money, budget, posting and consolidation projections.

Inspect the separate France-specific package when a selected composition needs that country layer.

Money, currency, scale and evidence must retain exact representations.

Consequential financial handoffs need current, bound approval.

Payment, invoicing and banking providers supply external effects.

Financial evidence must be correlatable without exposing sensitive payloads.

Start with immutable Work events, recurrence, sync conflict handling and durable-store ports.

Use CompanyOS authority, operating-loop, graph and outcome projections over shared references.

Inspect OPA planning/meeting services and their current authority and consent boundaries.

Inspect SupportOS lifecycle, case concurrency, routing and reference-based ecosystem handoffs.

Each domain declares the operation and event identity it owns.

Work and service operations are scoped to the current subject and workspace.

Communication owns message bodies and delivery used by these workflows.

Forms owns submitted answers and verification evidence.

Start with the source, policy and evidence contract vocabulary for OSINT.

Use source lifecycle, ingestion, qualification and scoped evidence projection logic.

Inspect candidate-private lifecycle, headless orchestration and effect-fencing responsibilities.

Inspect the opportunity domain’s declared models and references before composing an opportunity workflow.

Actor, candidate, purpose and grant scope are inputs to each effect and read.

Searchable knowledge is a derived aid with source/evidence bindings.

Web access, browser, email, storage and transport adapters execute selected external work.

Company and talent workflows consume eligible research through explicit references.

Use blog, email, social and marketing draft generators plus optimization reports.

Inspect referral/reward lifecycle and optional marketing/editorial execution over supplied ports.

Use creator campaign, agreement, submission and settlement lifecycle composition.

Inspect content analysis behavior separately from generation and publication.

Drafts, observations and publication actions need distinct contracts.

A publishing decision must bind the content actually reviewed.

Social, publishing, advertising and payment adapters own provider-specific effects.

Commercial rewards and settlements need exact money and evidence.

Use subject-bound authorization, command builders, replay and rights projections.

Explore onboarding, drills, coaching and progress adapters.

Inspect deterministic campaign, activity, XP, streak and replay behavior.

Inspect strict consent, normalization, sync and evidence boundaries for health-domain data.

Personal actions need an exact trusted subject and delegated scope.

Progress and personal records must preserve explicit units, time and provenance.

Personal inputs and consent-bearing records often enter through forms or exchanges.

Assistive agents receive only the selected, authorized personal context.

Start with integration specs, connections, secrets, provider interfaces and runtime/health contracts.

Inspect routing, runtime-target, observation, execution-receipt and comparison contracts.

Use runtime-target, routing and receipt normalization shared by provider hosts.

Inspect reusable integration-management composition for a selected product.

The consumer needs a declared capability and operation boundary.

A connection is usable only in its current trusted scope.

Agent model/tool routes consume explicit provider capabilities.

Execution targets and infrastructure providers have their own operational ports.

Inspect canonical delivery, runtime and execution contract families.

Use deterministic planning/execution, authorization verification and injected runtime-node ports.

Start with infrastructure intent, deployment, incident and evidence contracts.

Inspect source ingestion, readiness, planning and governed patch boundaries.

Execution uses authority bound to the exact work and current context.

Operational claims need source- and environment-bound evidence.

Concrete cloud, queue, state and ingress adapters implement supplied ports.

The selected host connects these capabilities into an actual product.

Use deterministic command-pack discovery, host ports and canonical workspace analysis/rendering leaves.

Inspect the actual CLI application that composes commands for users.

Explore pack loading, target-specific configuration, skills and plugin export.

Inspect the Markdown/registry-to-reference-index generation stage.

Authoring commands operate on declared specs and their source conventions.

Coding tools need scoped context and explicit instruction authority.

Source changes and generated artifacts enter existing quality/release workflows.

Command and editor flows should point to maintained examples.

Use vendor-neutral instrumentation, signals and evidence-facing surfaces.

Inspect declarative observability contracts before binding a backend.

Locate contract-aware testing utilities, generators, recorders and adapters.

Inspect the agent evaluation package for the selected agent task and environment.

Expected input, result and error behavior defines the test boundary.

Instrumentation and assertions must follow the actual handler/transport path.

Agent evaluations need a bound model, context and tool environment.

Source-bound quality evidence participates in release decisions.

Inspect shared product composition, feature hubs, shell and experience-coverage surfaces.

Inspect the selected founder-suite bundle and the product/domain components it composes.

Locate web routes and host-bound UI/server composition for the integrated application.

Locate the API host that binds operations to application authority and concrete services.

Composition connects exact capabilities, operations and references.

Each host must select and configure an execution/delivery boundary.

Design packs, feature hubs and role-aware views become product UI here.

Providers, workers, secrets and durable state are operational host responsibilities.

Use catalog-only discovery, then load runtime/host ports when a rich preview is needed.

Start with the maintained user-contract source and its small feature/handler structure.

Inspect the maintained table showcase and its declared source surfaces.

Explore the source pattern for knowledge retrieval combined with policy boundaries.

Recognize the contract, handler and adapter responsibilities in an example.

Know which host and execution path the example actually uses.

Table, RoleMorph and other UI examples illuminate rendering boundaries.

Agent examples need context, provider and tool evidence of their own.