@lssm/lib.contracts-spec 17.3.2

package/dist/self-improving-system/operations.js

@@ -0,0 +1 @@
+import*as e from"./operation-definitions.js";export*from"./operation-definitions.js";export const selfImprovementOperations=[e.SelfImprovementProgramUpsertCommand,e.SelfImprovementProgramListQuery,e.SelfImprovementProgramGetQuery,e.SelfImprovementProgramDisableCommand,e.SelfImprovementSignalIngestCommand,e.SelfImprovementSignalGetQuery,e.SelfImprovementSignalListQuery,e.SelfImprovementCandidateRequestCommand,e.SelfImprovementCandidateGetQuery,e.SelfImprovementCandidateListQuery,e.SelfImprovementCandidateCancelCommand,e.SelfImprovementEvaluationStatusQuery,e.SelfImprovementGateStatusQuery,e.SelfImprovementReviewRequestCommand,e.SelfImprovementReviewDecideCommand,e.SelfImprovementShadowStartCommand,e.SelfImprovementShadowStopCommand,e.SelfImprovementShadowCompareQuery,e.SelfImprovementCanaryStartCommand,e.SelfImprovementCanaryStopCommand,e.SelfImprovementCanaryCompareQuery,e.SelfImprovementObservationStatusQuery,e.SelfImprovementPromoteCommand,e.SelfImprovementRollbackCommand,e.SelfImprovementKillCommand,e.SelfImprovementReplayQuery];

package/dist/self-improving-system/registry.d.ts

@@ -0,0 +1,9 @@
+import type { AnyEventSpec } from '../events.js';
+import type { AnyOperationSpec } from '../operations/index.js';
+import { selfImprovementEvents } from './events.js';
+import { selfImprovementOperations } from './operations.js';
+export declare const selfImprovementOperationRegistry: Readonly<Record<string, AnyOperationSpec>>;
+export declare const selfImprovementEventRegistry: Readonly<Record<string, AnyEventSpec>>;
+export type SelfImprovementOperationKey = (typeof selfImprovementOperations)[number]['meta']['key'];
+export type SelfImprovementEventKey = (typeof selfImprovementEvents)[number]['meta']['key'];
+export declare function assertUniqueSelfImprovementContractKeys(): void;

package/dist/self-improving-system/registry.js

@@ -0,0 +1 @@
+import{selfImprovementEvents as r}from"./events.js";import{selfImprovementOperations as o}from"./operations.js";export const selfImprovementOperationRegistry=Object.fromEntries(o.map((e)=>[e.meta.key,e]));export const selfImprovementEventRegistry=Object.fromEntries(r.map((e)=>[e.meta.key,e]));export function assertUniqueSelfImprovementContractKeys(){const e=[...o.map((t)=>t.meta.key),...r.map((t)=>t.meta.key)];if(new Set(e).size!==e.length)throw Error("SELF_IMPROVEMENT_CONTRACT_KEY_COLLISION")}

package/dist/self-improving-system/transport.d.ts

@@ -0,0 +1,10 @@
+export type SelfImprovementTransportKindV1 = 'rest' | 'sdk' | 'mcp' | 'webhook' | 'sse' | 'websocket' | 'cli';
+export interface SelfImprovementTransportBindingV1 {
+    operationKey: string;
+    method: 'GET' | 'POST' | 'PATCH' | 'DELETE';
+    path: string;
+    transports: readonly SelfImprovementTransportKindV1[];
+    requiredGrant: 'read' | 'propose' | 'review' | 'execute' | 'admin';
+}
+export declare const selfImprovementTransportBindingsV1: readonly [SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1, SelfImprovementTransportBindingV1];
+export declare const selfImprovementDeliveryTransportsV1: readonly ["webhook", "sse", "websocket"];

package/dist/self-improving-system/transport.js

@@ -0,0 +1 @@
+const s=["rest","sdk","mcp","cli"];const e=(a,t,r,n)=>({operationKey:a,method:t,path:r,transports:s,requiredGrant:n});export const selfImprovementTransportBindingsV1=[e("self-improvement.program.upsert","POST","/programs","admin"),e("self-improvement.program.list","GET","/programs","read"),e("self-improvement.program.get","GET","/programs/:programId","read"),e("self-improvement.program.disable","POST","/programs/:programId/disable","admin"),e("self-improvement.signal.ingest","POST","/signals","propose"),e("self-improvement.signal.list","GET","/signals","read"),e("self-improvement.signal.get","GET","/signals/:signalId","read"),e("self-improvement.candidate.request","POST","/candidates","propose"),e("self-improvement.candidate.list","GET","/candidates","read"),e("self-improvement.candidate.get","GET","/candidates/:candidateId","read"),e("self-improvement.candidate.cancel","POST","/candidates/:candidateId/cancel","execute"),e("self-improvement.evaluation.status","GET","/candidates/:candidateId/evaluation","read"),e("self-improvement.gate.status","GET","/candidates/:candidateId/gates","read"),e("self-improvement.review.request","POST","/candidates/:candidateId/review-requests","execute"),e("self-improvement.review.decide","POST","/candidates/:candidateId/review","review"),e("self-improvement.shadow.start","POST","/candidates/:candidateId/shadow","execute"),e("self-improvement.shadow.stop","POST","/candidates/:candidateId/shadow/stop","execute"),e("self-improvement.shadow.compare","GET","/candidates/:candidateId/shadow/comparison","read"),e("self-improvement.canary.start","POST","/candidates/:candidateId/canary","execute"),e("self-improvement.canary.stop","POST","/candidates/:candidateId/canary/stop","execute"),e("self-improvement.canary.compare","GET","/candidates/:candidateId/canary/comparison","read"),e("self-improvement.observation.status","GET","/candidates/:candidateId/observation","read"),e("self-improvement.promote","POST","/candidates/:candidateId/promote","execute"),e("self-improvement.rollback","POST","/candidates/:candidateId/rollback","execute"),e("self-improvement.kill","POST","/programs/:programId/kill","admin"),e("self-improvement.replay.get","GET","/events","read")];export const selfImprovementDeliveryTransportsV1=["webhook","sse","websocket"];

package/dist/self-improving-system/types.d.ts

@@ -0,0 +1,136 @@
+import type { ImprovementObservationPlanV1, OperationalImprovementSignalV1 } from '../ai-improvement/contracts-v2.js';
+import type { SELF_IMPROVEMENT_AUTONOMY_LEVELS, SELF_IMPROVEMENT_CANDIDATE_KINDS, SELF_IMPROVEMENT_STATUSES } from './constants.js';
+export declare const SELF_IMPROVEMENT_PROGRAM_V1: 'contractspec.self-improvement.program.v1';
+export declare const SELF_IMPROVEMENT_CANDIDATE_V1: 'contractspec.self-improvement.candidate.v1';
+export declare const SELF_IMPROVEMENT_EXECUTION_ENVELOPE_V1: 'contractspec.self-improvement.execution-envelope.v1';
+export declare const SELF_IMPROVEMENT_LIFECYCLE_RECEIPT_V1: 'contractspec.self-improvement.lifecycle-receipt.v1';
+export declare const SELF_IMPROVEMENT_MUTATION_ENVELOPE_V1: 'contractspec.self-improvement.mutation-envelope.v1';
+export type SelfImprovementAutonomyLevelV1 = (typeof SELF_IMPROVEMENT_AUTONOMY_LEVELS)[number];
+export type SelfImprovementCandidateKindV1 = (typeof SELF_IMPROVEMENT_CANDIDATE_KINDS)[number];
+export type SelfImprovementStatusV1 = (typeof SELF_IMPROVEMENT_STATUSES)[number];
+export interface SelfImprovementScopeV1 {
+    ecosystemId: string;
+    tenantId: string;
+    workspaceId: string;
+    programId: string;
+    jurisdiction: string;
+    purpose: string;
+}
+export interface ImmutableArtifactRefV1 {
+    id: string;
+    digest: string;
+    version: string;
+}
+export interface SelfImprovementMutationEnvelopeV1 {
+    schemaVersion: typeof SELF_IMPROVEMENT_MUTATION_ENVELOPE_V1;
+    idempotencyKey: string;
+    expectedRevision: number;
+    contractFingerprint: string;
+    traceRef: string;
+    evidenceRefs: string[];
+}
+export interface SelfImprovementBudgetV1 {
+    currency: string;
+    maximumCost: number;
+    maximumRuntimeMs: number;
+    maximumCandidates: number;
+    reservationRef: string;
+}
+export interface SelfImprovementDeploymentProfileV1 {
+    mode: 'logical' | 'runtime_isolated' | 'data_isolated';
+    region: string;
+    credentialScopeRef: string;
+    networkPolicyRef: string;
+    dataPolicyRef: string;
+}
+export interface SelfImprovementProgramV1 {
+    schemaVersion: typeof SELF_IMPROVEMENT_PROGRAM_V1;
+    id: string;
+    revision: number;
+    scope: SelfImprovementScopeV1;
+    goalRevision: ImmutableArtifactRefV1;
+    signalKinds: OperationalImprovementSignalV1['kind'][];
+    allowedCandidateTargets: string[];
+    evaluationSuiteRefs: ImmutableArtifactRefV1[];
+    requiredGateIds: string[];
+    observationPlan: ImprovementObservationPlanV1;
+    autonomy: SelfImprovementAutonomyLevelV1;
+    budget: SelfImprovementBudgetV1;
+    deploymentProfile: SelfImprovementDeploymentProfileV1;
+    killSwitchKey: string;
+    enabled: boolean;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: string;
+}
+export interface SelfImprovementCandidateV1 {
+    schemaVersion: typeof SELF_IMPROVEMENT_CANDIDATE_V1;
+    id: string;
+    programId: string;
+    programRevision: number;
+    kind: SelfImprovementCandidateKindV1;
+    status: SelfImprovementStatusV1;
+    baseline: ImmutableArtifactRefV1;
+    candidate: ImmutableArtifactRefV1;
+    risk: 'low' | 'medium' | 'high' | 'unknown';
+    targetRefs: string[];
+    allowedCapabilities: string[];
+    allowedPaths: string[];
+    generatorIdentityRef: string;
+    evaluatorIdentityRef: string;
+    approverIdentityRef?: string;
+    rollbackRef: string;
+    createdAt: string;
+    expiresAt: string;
+}
+interface SelfImprovementExecutionEnvelopeBaseV1 {
+    schemaVersion: typeof SELF_IMPROVEMENT_EXECUTION_ENVELOPE_V1;
+    id: string;
+    program: ImmutableArtifactRefV1;
+    goal: ImmutableArtifactRefV1;
+    policy: ImmutableArtifactRefV1;
+    budgetReservation: ImmutableArtifactRefV1;
+    gateBundle: ImmutableArtifactRefV1;
+    lssmPlan: ImmutableArtifactRefV1;
+    connectDecision: ImmutableArtifactRefV1;
+    runtimeWorkOrder?: ImmutableArtifactRefV1;
+    patchRunReceipt?: ImmutableArtifactRefV1;
+    canary?: ImmutableArtifactRefV1;
+    observation: ImmutableArtifactRefV1;
+    rollback: ImmutableArtifactRefV1;
+    replay: ImmutableArtifactRefV1;
+    issuedAt: string;
+    expiresAt: string;
+}
+type SelfImprovementApprovalBindingV1 = {
+    approval?: never;
+    approvalVerification?: never;
+} | {
+    /** Signed independent approval bound to exact program, candidate, and gates. */
+    approval: ImmutableArtifactRefV1;
+    /** Signature-verification receipt from the configured approval authority. */
+    approvalVerification: ImmutableArtifactRefV1;
+};
+export type SelfImprovementExecutionEnvelopeV1 = SelfImprovementExecutionEnvelopeBaseV1 & SelfImprovementApprovalBindingV1;
+export interface SelfImprovementLifecycleReceiptV1 {
+    schemaVersion: typeof SELF_IMPROVEMENT_LIFECYCLE_RECEIPT_V1;
+    id: string;
+    candidateId: string;
+    fromStatus: SelfImprovementStatusV1;
+    toStatus: SelfImprovementStatusV1;
+    actorIdentityRef: string;
+    decisionRef: string;
+    evidenceRefs: ImmutableArtifactRefV1[];
+    previousStateDigest: string;
+    resultingStateDigest: string;
+    occurredAt: string;
+}
+export declare const selfImprovingSystemV1DocBlock: {
+    id: string;
+    title: string;
+    body: string;
+    kind: "reference";
+    route: string;
+    visibility: "public";
+};
+export {};

package/dist/self-improving-system/types.js

@@ -0,0 +1 @@
+export const SELF_IMPROVEMENT_PROGRAM_V1="contractspec.self-improvement.program.v1";export const SELF_IMPROVEMENT_CANDIDATE_V1="contractspec.self-improvement.candidate.v1";export const SELF_IMPROVEMENT_EXECUTION_ENVELOPE_V1="contractspec.self-improvement.execution-envelope.v1";export const SELF_IMPROVEMENT_LIFECYCLE_RECEIPT_V1="contractspec.self-improvement.lifecycle-receipt.v1";export const SELF_IMPROVEMENT_MUTATION_ENVELOPE_V1="contractspec.self-improvement.mutation-envelope.v1";export const selfImprovingSystemV1DocBlock={id:"self-improving-system-v1",title:"Governed self-improving system V1",body:"Additive contracts bind improvement programs and candidates to immutable goals, budgets, policy, offline and independent evaluation, G01-G25 evidence, shadow and canary comparisons, Connect decisions, Builder receipts, LSSM plans, Runtime Node V2 work orders, observation, rollback, and exact replay. Runtime artifacts may use qualified automation; repository, schema, data-authority, security, and infrastructure changes remain approval-bound and repository work never self-applies.",kind:"reference",route:"packages/libs/contracts-spec/src/self-improving-system/types.ts",visibility:"public"};

package/dist/self-improving-system/validation.d.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod';
+export declare const immutableArtifactRefV1Schema: z.ZodObject<{
+    id: z.ZodString;
+    digest: z.ZodString;
+    version: z.ZodString;
+}, z.core.$strict>;
+export declare const selfImprovementMutationEnvelopeV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.self-improvement.mutation-envelope.v1">;
+    idempotencyKey: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    contractFingerprint: z.ZodString;
+    traceRef: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export declare const selfImprovementProgramV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.self-improvement.program.v1">;
+    id: z.ZodString;
+    revision: z.ZodNumber;
+    scope: z.ZodObject<{
+        ecosystemId: z.ZodString;
+        tenantId: z.ZodString;
+        workspaceId: z.ZodString;
+        programId: z.ZodString;
+        jurisdiction: z.ZodString;
+        purpose: z.ZodString;
+    }, z.core.$strict>;
+    goalRevision: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    signalKinds: z.ZodArray<z.ZodEnum<{
+        evaluation_failure: "evaluation_failure";
+        operational_metric: "operational_metric";
+        operator_correction: "operator_correction";
+        runtime_failure: "runtime_failure";
+        user_feedback: "user_feedback";
+    }>>;
+    allowedCandidateTargets: z.ZodArray<z.ZodString>;
+    evaluationSuiteRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    requiredGateIds: z.ZodArray<z.ZodString>;
+    observationPlan: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"contractspec.improvement-observation-plan.v1">;
+        id: z.ZodString;
+        windowMs: z.ZodNumber;
+        timeoutMs: z.ZodNumber;
+        minSampleCount: z.ZodNumber;
+        missingDataAction: z.ZodEnum<{
+            require_review: "require_review";
+            rollback: "rollback";
+        }>;
+        metrics: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            direction: z.ZodEnum<{
+                higher_is_better: "higher_is_better";
+                lower_is_better: "lower_is_better";
+                zero_tolerance: "zero_tolerance";
+            }>;
+            baselineValue: z.ZodNumber;
+            maximumRelativeRegression: z.ZodNumber;
+            absoluteThreshold: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    autonomy: z.ZodEnum<{
+        apply_with_approval: "apply_with_approval";
+        auto_apply_qualified: "auto_apply_qualified";
+        observe: "observe";
+        plan: "plan";
+        recommend: "recommend";
+    }>;
+    budget: z.ZodObject<{
+        currency: z.ZodString;
+        maximumCost: z.ZodNumber;
+        maximumRuntimeMs: z.ZodNumber;
+        maximumCandidates: z.ZodNumber;
+        reservationRef: z.ZodString;
+    }, z.core.$strict>;
+    deploymentProfile: z.ZodObject<{
+        mode: z.ZodEnum<{
+            data_isolated: "data_isolated";
+            logical: "logical";
+            runtime_isolated: "runtime_isolated";
+        }>;
+        region: z.ZodString;
+        credentialScopeRef: z.ZodString;
+        networkPolicyRef: z.ZodString;
+        dataPolicyRef: z.ZodString;
+    }, z.core.$strict>;
+    killSwitchKey: z.ZodString;
+    enabled: z.ZodBoolean;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;
+export declare const selfImprovementCandidateV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.self-improvement.candidate.v1">;
+    id: z.ZodString;
+    programId: z.ZodString;
+    programRevision: z.ZodNumber;
+    kind: z.ZodEnum<{
+        repository_work_item: "repository_work_item";
+        runtime_artifact: "runtime_artifact";
+    }>;
+    status: z.ZodEnum<{
+        awaiting_approval: "awaiting_approval";
+        canary: "canary";
+        evaluating: "evaluating";
+        expired: "expired";
+        failed: "failed";
+        killed: "killed";
+        observing: "observing";
+        promoted: "promoted";
+        proposing: "proposing";
+        queued: "queued";
+        rejected: "rejected";
+        rolled_back: "rolled_back";
+        shadow: "shadow";
+    }>;
+    baseline: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    candidate: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    risk: z.ZodEnum<{
+        high: "high";
+        low: "low";
+        medium: "medium";
+        unknown: "unknown";
+    }>;
+    targetRefs: z.ZodArray<z.ZodString>;
+    allowedCapabilities: z.ZodArray<z.ZodString>;
+    allowedPaths: z.ZodArray<z.ZodString>;
+    generatorIdentityRef: z.ZodString;
+    evaluatorIdentityRef: z.ZodString;
+    approverIdentityRef: z.ZodOptional<z.ZodString>;
+    rollbackRef: z.ZodString;
+    createdAt: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;
+export declare const selfImprovementExecutionEnvelopeV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.self-improvement.execution-envelope.v1">;
+    id: z.ZodString;
+    program: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    goal: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    policy: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    budgetReservation: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    gateBundle: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    lssmPlan: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    connectDecision: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    approval: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    approvalVerification: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    runtimeWorkOrder: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    patchRunReceipt: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    canary: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    observation: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    rollback: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    replay: z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>;
+    issuedAt: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strict>;
+export declare const selfImprovementLifecycleReceiptV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"contractspec.self-improvement.lifecycle-receipt.v1">;
+    id: z.ZodString;
+    candidateId: z.ZodString;
+    fromStatus: z.ZodEnum<{
+        awaiting_approval: "awaiting_approval";
+        canary: "canary";
+        evaluating: "evaluating";
+        expired: "expired";
+        failed: "failed";
+        killed: "killed";
+        observing: "observing";
+        promoted: "promoted";
+        proposing: "proposing";
+        queued: "queued";
+        rejected: "rejected";
+        rolled_back: "rolled_back";
+        shadow: "shadow";
+    }>;
+    toStatus: z.ZodEnum<{
+        awaiting_approval: "awaiting_approval";
+        canary: "canary";
+        evaluating: "evaluating";
+        expired: "expired";
+        failed: "failed";
+        killed: "killed";
+        observing: "observing";
+        promoted: "promoted";
+        proposing: "proposing";
+        queued: "queued";
+        rejected: "rejected";
+        rolled_back: "rolled_back";
+        shadow: "shadow";
+    }>;
+    actorIdentityRef: z.ZodString;
+    decisionRef: z.ZodString;
+    evidenceRefs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        digest: z.ZodString;
+        version: z.ZodString;
+    }, z.core.$strict>>;
+    previousStateDigest: z.ZodString;
+    resultingStateDigest: z.ZodString;
+    occurredAt: z.ZodString;
+}, z.core.$strict>;

package/dist/self-improving-system/validation.js

@@ -0,0 +1 @@
+import{z as t}from"zod";import{improvementObservationPlanV1Schema as s}from"../ai-improvement/validation-v2.js";import{SELF_IMPROVEMENT_AUTONOMY_LEVELS as m,SELF_IMPROVEMENT_CANDIDATE_KINDS as c,SELF_IMPROVEMENT_STATUSES as n}from"./constants.js";import{SELF_IMPROVEMENT_CANDIDATE_V1 as d,SELF_IMPROVEMENT_EXECUTION_ENVELOPE_V1 as p,SELF_IMPROVEMENT_LIFECYCLE_RECEIPT_V1 as l,SELF_IMPROVEMENT_MUTATION_ENVELOPE_V1 as u,SELF_IMPROVEMENT_PROGRAM_V1 as f}from"./types.js";const e=t.string().trim().min(1);const r=t.number().int().positive();const a=e;export const immutableArtifactRefV1Schema=t.object({id:e,digest:e,version:e}).strict();export const selfImprovementMutationEnvelopeV1Schema=t.object({schemaVersion:t.literal(u),idempotencyKey:e,expectedRevision:t.number().int().nonnegative(),contractFingerprint:e,traceRef:e,evidenceRefs:t.array(e).min(1)}).strict();const E=t.object({ecosystemId:e,tenantId:e,workspaceId:e,programId:e,jurisdiction:e,purpose:e}).strict();export const selfImprovementProgramV1Schema=t.object({schemaVersion:t.literal(f),id:e,revision:r,scope:E,goalRevision:immutableArtifactRefV1Schema,signalKinds:t.array(t.enum(["user_feedback","operational_metric","runtime_failure","evaluation_failure","operator_correction"])).min(1),allowedCandidateTargets:t.array(e).min(1),evaluationSuiteRefs:t.array(immutableArtifactRefV1Schema).min(1),requiredGateIds:t.array(e).min(1),observationPlan:s,autonomy:t.enum(m),budget:t.object({currency:e,maximumCost:t.number().finite().nonnegative(),maximumRuntimeMs:r,maximumCandidates:r,reservationRef:e}).strict(),deploymentProfile:t.object({mode:t.enum(["logical","runtime_isolated","data_isolated"]),region:e,credentialScopeRef:e,networkPolicyRef:e,dataPolicyRef:e}).strict(),killSwitchKey:e,enabled:t.boolean(),createdAt:a,updatedAt:a,expiresAt:a}).strict().superRefine((o,i)=>{if(o.scope.programId!==o.id)i.addIssue({code:"custom",path:["scope","programId"],message:"scope programId must equal id"});if(o.autonomy==="auto_apply_qualified"&&!o.killSwitchKey)i.addIssue({code:"custom",path:["killSwitchKey"],message:"qualified automation requires a kill switch"})});export const selfImprovementCandidateV1Schema=t.object({schemaVersion:t.literal(d),id:e,programId:e,programRevision:r,kind:t.enum(c),status:t.enum(n),baseline:immutableArtifactRefV1Schema,candidate:immutableArtifactRefV1Schema,risk:t.enum(["low","medium","high","unknown"]),targetRefs:t.array(e).min(1),allowedCapabilities:t.array(e),allowedPaths:t.array(e),generatorIdentityRef:e,evaluatorIdentityRef:e,approverIdentityRef:e.optional(),rollbackRef:e,createdAt:a,expiresAt:a}).strict().superRefine((o,i)=>{if(o.generatorIdentityRef===o.evaluatorIdentityRef)i.addIssue({code:"custom",path:["evaluatorIdentityRef"],message:"generator and evaluator must be independent"});if(o.kind==="repository_work_item"&&o.allowedPaths.length===0)i.addIssue({code:"custom",path:["allowedPaths"],message:"repository work requires bounded paths"})});export const selfImprovementExecutionEnvelopeV1Schema=t.object({schemaVersion:t.literal(p),id:e,program:immutableArtifactRefV1Schema,goal:immutableArtifactRefV1Schema,policy:immutableArtifactRefV1Schema,budgetReservation:immutableArtifactRefV1Schema,gateBundle:immutableArtifactRefV1Schema,lssmPlan:immutableArtifactRefV1Schema,connectDecision:immutableArtifactRefV1Schema,approval:immutableArtifactRefV1Schema.optional(),approvalVerification:immutableArtifactRefV1Schema.optional(),runtimeWorkOrder:immutableArtifactRefV1Schema.optional(),patchRunReceipt:immutableArtifactRefV1Schema.optional(),canary:immutableArtifactRefV1Schema.optional(),observation:immutableArtifactRefV1Schema,rollback:immutableArtifactRefV1Schema,replay:immutableArtifactRefV1Schema,issuedAt:a,expiresAt:a}).strict().refine((o)=>Boolean(o.runtimeWorkOrder)!==Boolean(o.patchRunReceipt),{message:"exactly one execution authority must be bound",path:["runtimeWorkOrder"]}).refine((o)=>Boolean(o.approval)===Boolean(o.approvalVerification),{message:"approval and approval verification must be bound together",path:["approvalVerification"]});export const selfImprovementLifecycleReceiptV1Schema=t.object({schemaVersion:t.literal(l),id:e,candidateId:e,fromStatus:t.enum(n),toStatus:t.enum(n),actorIdentityRef:e,decisionRef:e,evidenceRefs:t.array(immutableArtifactRefV1Schema).min(1),previousStateDigest:e,resultingStateDigest:e,occurredAt:a}).strict();

package/dist/serialization/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Serialization types for Server -> Client Component transfer.
+ *
+ * These types represent plain JSON-serializable versions of spec types,
+ * suitable for passing from Server Components to Client Components in Next.js.
+ * They strip away class instances (like SchemaModel) and keep only
+ * the essential data needed for display.
+ */
+export * from './serializers.js';
+export * from './types.js';

package/dist/serialization/index.js

@@ -0,0 +1 @@
+export*from"./serializers.js";export*from"./types.js";

package/dist/serialization/serializers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Serialization functions for converting spec types to their serialized forms.
+ */
+import type { AnySchemaModel } from '@lssm/lib.schema';
+import type { DataViewSpec } from '../data-views/index.js';
+import type { AnyEventSpec } from '../events.js';
+import type { FormSpec } from '../forms/index.js';
+import type { AnyOperationSpec } from '../operations/index.js';
+import type { PresentationSpec } from '../presentations/index.js';
+import type { ResourceRefDescriptor } from '../resources.js';
+import type { SerializedDataViewSpec, SerializedEventSpec, SerializedFormSpec, SerializedOperationSpec, SerializedPresentationSpec, SerializedSchemaModel } from './types.js';
+/**
+ * Serialize a SchemaModel to a plain JSON object.
+ */
+export declare function serializeSchemaModel(model: AnySchemaModel | ResourceRefDescriptor<boolean> | null | undefined): SerializedSchemaModel | null;
+/**
+ * Serialize an OperationSpec to a plain JSON object.
+ */
+export declare function serializeOperationSpec(spec: AnyOperationSpec | null | undefined): SerializedOperationSpec | null;
+/**
+ * Serialize an EventSpec to a plain JSON object.
+ */
+export declare function serializeEventSpec(spec: AnyEventSpec | null | undefined): SerializedEventSpec | null;
+/**
+ * Serialize a PresentationSpec to a plain JSON object.
+ */
+export declare function serializePresentationSpec(spec: PresentationSpec | null | undefined): SerializedPresentationSpec | null;
+/**
+ * Serialize a DataViewSpec to a plain JSON object.
+ */
+export declare function serializeDataViewSpec(spec: DataViewSpec | null | undefined): SerializedDataViewSpec | null;
+/**
+ * Serialize a FormSpec to a plain JSON object.
+ */
+export declare function serializeFormSpec(spec: FormSpec | null | undefined): SerializedFormSpec | null;

package/dist/serialization/serializers.js

@@ -0,0 +1 @@
+function r(e){return typeof e==="object"&&e!==null&&"kind"in e&&e.kind==="resource_ref"}function o(e){if(!e)return"unknown";if(typeof e==="string")return e;if(typeof e==="object"){if("config"in e&&e.config?.name)return e.config.name;if("name"in e&&typeof e.name==="string")return e.name}return"unknown"}export function serializeSchemaModel(e){if(!e)return null;if(r(e))return{name:`ResourceRef<${e.graphQLType}>`,description:`Reference to ${e.graphQLType} resource (${e.uriTemplate})`,fields:{}};if("config"in e&&e.config){const n=e.config;return{name:n.name,description:n.description,fields:Object.fromEntries(Object.entries(n.fields).map(([i,t])=>[i,{typeName:o(t.type),isOptional:t.isOptional,isArray:t.isArray}]))}}return{name:"unknown",fields:{}}}export function serializeOperationSpec(e){if(!e)return null;return{meta:{key:e.meta.key,version:e.meta.version,stability:e.meta.stability,owners:e.meta.owners,tags:e.meta.tags,description:e.meta.description,goal:e.meta.goal,context:e.meta.context},io:{input:serializeSchemaModel(e.io.input),output:serializeSchemaModel(e.io.output)},policy:e.policy?{auth:e.policy.auth}:void 0}}export function serializeEventSpec(e){if(!e)return null;return{meta:{key:e.meta.key,version:e.meta.version,stability:e.meta.stability,owners:e.meta.owners,tags:e.meta.tags,description:e.meta.description},payload:serializeSchemaModel(e.payload)}}export function serializePresentationSpec(e){if(!e)return null;return{meta:{key:e.meta.key,version:e.meta.version,stability:e.meta.stability,owners:e.meta.owners,tags:e.meta.tags,description:e.meta.description,goal:e.meta.goal,context:e.meta.context},source:{type:e.source.type,framework:e.source.type==="component"?e.source.framework:void 0,componentKey:e.source.type==="component"?e.source.componentKey:void 0},targets:e.targets}}export function serializeDataViewSpec(e){if(!e)return null;return{meta:{key:e.meta.key,version:e.meta.version,stability:e.meta.stability,owners:e.meta.owners,tags:e.meta.tags,description:e.meta.description,title:e.meta.title},source:e.source,view:e.view}}export function serializeFormSpec(e){if(!e)return null;return{meta:{key:e.meta.key,version:e.meta.version,stability:e.meta.stability,owners:e.meta.owners,tags:e.meta.tags,description:e.meta.description,title:e.meta.title},fields:e.fields,actions:e.actions}}

package/dist/serialization/types.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Serialized types for Server -> Client Component transfer.
+ *
+ * These are plain JSON-serializable versions of spec types that can be
+ * safely passed from Server Components to Client Components in Next.js.
+ */
+/** Serialized schema model that can be passed to client components */
+export interface SerializedSchemaModel {
+    name: string;
+    description?: string | null;
+    fields: Record<string, SerializedFieldConfig>;
+}
+export interface SerializedFieldConfig {
+    typeName: string;
+    isOptional: boolean;
+    isArray?: boolean;
+}
+/** Serialized operation spec for client components */
+export interface SerializedOperationSpec {
+    meta: {
+        key: string;
+        version: string;
+        stability?: string;
+        owners?: string[];
+        tags?: string[];
+        description?: string;
+        goal?: string;
+        context?: string;
+    };
+    io: {
+        input: SerializedSchemaModel | null;
+        output: SerializedSchemaModel | null;
+    };
+    policy?: {
+        auth?: string;
+    };
+}
+/** Serialized event spec for client components */
+export interface SerializedEventSpec {
+    meta: {
+        key: string;
+        version: string;
+        stability?: string;
+        owners?: string[];
+        tags?: string[];
+        description?: string;
+    };
+    payload: SerializedSchemaModel | null;
+}
+/** Serialized presentation spec for client components */
+export interface SerializedPresentationSpec {
+    meta: {
+        key: string;
+        version: string;
+        stability?: string;
+        owners?: string[];
+        tags?: string[];
+        description?: string;
+        goal?: string;
+        context?: string;
+    };
+    source: {
+        type: string;
+        framework?: string;
+        componentKey?: string;
+    };
+    targets?: string[];
+}
+/** Serialized data view spec for client components */
+export interface SerializedDataViewSpec {
+    meta: {
+        key: string;
+        version: string;
+        stability?: string;
+        owners?: string[];
+        tags?: string[];
+        description?: string;
+        title?: string;
+    };
+    /** Serialized source configuration */
+    source?: unknown;
+    /** Serialized view configuration */
+    view?: unknown;
+}
+/** Serialized form spec for client components */
+export interface SerializedFormSpec {
+    meta: {
+        key: string;
+        version?: string;
+        stability?: string;
+        owners?: string[];
+        tags?: string[];
+        description?: string;
+        title?: string;
+    };
+    /** Serialized form fields (passed through for display) */
+    fields?: unknown;
+    /** Serialized form actions (passed through for display) */
+    actions?: unknown;
+}