clp-runtime-init
// ═══════════════════════════════════════════════ //

Authority-first execution protocol for AI-assisted systems.

> Deterministic boundary between intelligence and authority

INVARIANT: AI may propose values, but never directly cause state changes
$npm install @yav-ai/clpView on GitHub
scroll to explore
Runtime API

Define contracts. Enforce authority.

CLP uses minimal primitives — intents, guards, transitions — to create deterministic execution boundaries around AI systems.

contract-demo.ts
LIVE
TypeScriptStep 1/4 — createContract
Architecture

Minimal primitives. Maximum authority.

Four primitives form the entire execution model. Each is explicit, auditable, and deterministic.

>>

INTENTS

What is being attempted

Declare what the system intends to do. Intents carry payloads and can be dispatched complete or incomplete.

[]

GUARDS

Hard prohibitions

Non-negotiable rules. If a guard denies, the transition is blocked. No exceptions. No overrides.

=>

TRANSITIONS

Atomic state changes

The only pathway for state mutation. Transitions fire atomically after all guards pass.

{}

STATE

Authoritative truth

The single source of truth. Opaque to AI. Only transitions can modify state.

INTENT
dispatch()▼
GUARD
evaluate()▼
TRANSITION
commit()▼
STATE
subscribe()
Execution Lifecycle

dispatch → propose → accept → commit

Every state change follows an explicit, auditable path. No shortcuts. No silent mutations.

PHASE 01dispatch()DISPATCHED

Intent Dispatched

An intent is declared — complete or incomplete. This is the entry point. The system now knows what is being attempted.

> runtime.dispatch("increment", { amount: 5 })
PHASE 02propose()PROPOSED

AI Proposes

AI may optionally suggest missing values. Proposals are sandboxed, untrusted, and never auto-applied. AI assists but does not decide.

> await runtime.propose("increment")
  [AI] → { amount: 5 }
  [SYS] Proposal staged. Awaiting acceptance.
PHASE 03acceptProposal()ACCEPTED

Explicit Acceptance

A human or deterministic system must explicitly accept the proposal. This is the authority boundary — the point where intelligence meets control.

> runtime.acceptProposal("increment")
  [OK ] Proposal accepted into intent payload.
PHASE 04guardsCLEARED

Guards Enforce

Hard, non-negotiable rules evaluate the intent. If any guard denies, the transition is permanently blocked. No bypass. No override.

  [GUARD] no_negative → PASS
  [GUARD] max_limit  → PASS
  [OK   ] All guards passed.
PHASE 05commit()COMMITTED

State Transitions

The transition fires atomically. State changes are applied. The audit log records every step. Deterministic. Replayable. Complete.

> runtime.commit("apply")
  [STATE] count: 0 → 5
  [LOG  ] Commit recorded. Audit trail complete.
Scope

CLP does not make decisions.

It verifies whether decisions are allowed to execute.

+

CLP IS

  • >A contract language protocol
  • >A runtime authority layer
  • >A deterministic execution boundary
  • >A foundation for auditable AI systems
  • >Framework-agnostic by design
x

CLP IS NOT

  • ~A prompt framework
  • ~An AI orchestration engine
  • ~A workflow DSL
  • ~A UI framework
  • ~A replacement for business logic
Design Principles

Built for trust. Not for hype.

AUTH

Authority Before Intelligence

AI is always treated as untrusted input until explicitly accepted. No model output can bypass the contract boundary.

> policy: authority_first = TRUE
CNTR

Contracts Over Conventions

Rules live in executable code, not in prompts or documentation. Contracts are verifiable, testable, and enforceable.

> mode: contract_enforced = ACTIVE
DTRM

Determinism at the Edges

All state changes are explainable, replayable, and auditable. Every transition produces an immutable log entry.

> trace: deterministic_audit = ENABLED
BORE

Boring by Design

Cleverness is avoided where it could weaken guarantees. CLP is intentionally simple, predictable, and transparent.

> complexity: minimal_surface = LOCKED
Integration Modes
NO DEPS

Standalone

CLP governs execution directly

PROPOSALS

With LLMs

AI generates proposals only

AUTHORITY

With LangChain

LangChain reasons, CLP enforces

CLP never depends on any AI framework. Integrations are optional and additive.